Quantum controller architecture

ABSTRACT

A system comprises pulse generation and measurement circuitry comprising a plurality of pulse generator circuits and a plurality of ports, and management circuitry. The management circuitry is operable to analyze a specification of a controlled system and controlled elements that comprises a definition of a controlled element of the control system, and a definition of one or more pulses available for transmission by the control system. The management circuitry is operable to configure, based on the specification, the pulse generation and measurement circuitry to: generate the one or more pulses via one or more of the plurality of pulse generator circuits; and output the one or more pulses to the controlled element via one or more of the plurality of ports.

PRIORITY CLAIM

This application is a continuation of application Ser. No. 17/459,062filed Aug. 27, 2021, which is a continuation of application Ser. No.17/088,973 filed Nov. 4, 2020, which is a continuation of applicationSer. No. 16/708,780 filed Dec. 10, 2019 (Patent No. 10,862,465), whichclaims priority to U.S. provisional patent application 62/894,905 filedSep. 2, 2019. The aforementioned documents are each hereby incorporatedherein by reference in their entirety.

BACKGROUND

Limitations and disadvantages of conventional approaches to quantumcomputer control systems will become apparent to one of skill in theart, through comparison of such approaches with some aspects of thepresent method and system set forth in the remainder of this disclosurewith reference to the drawings.

BRIEF SUMMARY

Methods and systems are provided for a quantum controller, substantiallyas illustrated by and/or described in connection with at least one ofthe figures, as set forth more completely in the claims.

BRIEF DESCRIPTION OF THE DRAWINGS

FIGS. 1A and 1B compare some aspects of classical (binary) computing andquantum computing.

FIG. 2 shows an example quantum orchestration platform.

FIG. 3A shows an example quantum orchestration platform (QOP)architecture in accordance with various example implementations of thisdisclosure.

FIG. 3B shows an example implementation of the quantum controllercircuitry of FIG. 3A.

FIG. 4 shows an example implementation of the pulser of FIG. 3B.

FIG. 5 shows an example implementation of the pulse operations managerand pulse operations circuitry of FIG. 3B.

FIG. 6A shows frequency generation circuitry of the quantum controllerof FIG. 3B.

FIG. 6B shows example components of the control signal IF_(l) of FIG.6A.

FIG. 7 shows an example implementation of the digital manager of FIG.3B.

FIG. 8 shows an example implementation of the digital manager of FIG.3B.

FIG. 9 illustrates configuration and control of the quantum controllervia the quantum programming subsystem.

FIGS. 10A-10C show an example quantum machine specification.

FIG. 11 is a flow chart showing an example operation of the QOP.

FIG. 12A shows a portion of a quantum machine configured to perform aPower Rabi calibration.

FIG. 12B shows the result of a Power Rabi calibration.

FIGS. 13A and 13B illustrate the modular and reconfigurable nature ofthe QOP.

DETAILED DESCRIPTION

Classical computers operate by storing information in the form of binarydigits (“bits”) and processing those bits via binary logic gates. At anygiven time, each bit takes on only one of two discrete values: 0 (or“off”) and 1 (or “on”). The logical operations performed by the binarylogic gates are defined by Boolean algebra and circuit behavior isgoverned by classical physics. In a modern classical system, thecircuits for storing the bits and realizing the logical operations areusually made from electrical wires that can carry two differentvoltages, representing the 0 and 1 of the bit, and transistor-basedlogic gates that perform the Boolean logic operations.

Shown in FIG. 1A is a simple example of a classical computer configuredto a bit 102 and apply a single logic operation 104 to the bit 102. Attime t0 the bit 102 is in a first state, at time t1 the logic operation104 is applied to the bit 102, and at time t2 the bit 102 is in a secondstate determined by the state at time t0 and the logic operation. So,for example, the bit 102 may typically be stored as a voltage (e.g., 1Vdc for a “1” or 0 Vdc for a “0”) which is applied to an input of thelogic operation 104 (comprised of one or more transistors). The outputof the logic gate is then either 1 Vdc or 0 Vdc, depending on the logicoperation performed.

Obviously, a classical computer with a single bit and single logic gateis of limited use, which is why modern classical computers with evenmodest computation power contain billions of bits and transistors. Thatis to say, classical computers that can solve increasingly complexproblems inevitably require increasingly large numbers of bits andtransistors and/or increasingly long amounts of time for carrying outthe algorithms. There are, however, some problems which would require aninfeasibly large number of transistors and/or infeasibly long amount oftime to arrive at a solution. Such problems are referred to asintractable.

Quantum computers operate by storing information in the form of quantumbits (“qubits”) and processing those qubits via quantum gates. Unlike abit which can only be in one state (either 0 or 1) at any given time, aqubit can be in a superposition of the two states at the same time. Moreprecisely, a quantum bit is a system whose state lives in a twodimensional Hilbert space and is therefore described as a linearcombination α|0

+β|1

, where |0

and |1

are two basis states, and α and β are complex numbers, usually calledprobability amplitudes, which satisfy |α|²+|β|3 ²=1. Using thisnotation, when the qubit is measured, it will be 0 with probability |α|²and will be 1 with probability |β|². |0

and |1

can also be represented by two-dimensional basis vectors

${\begin{bmatrix}1 \\0\end{bmatrix}{{and}\begin{bmatrix}0 \\1\end{bmatrix}}},$respectively, and then the qubit state is represented by

$\begin{bmatrix}\alpha \\\beta\end{bmatrix}.$The operations performed by the quantum gates are defined by linearalgebra over Hilbert space and circuit behavior is governed by quantumphysics. This extra richness in the mathematical behavior of qubits andthe operations on them, enables quantum computers to solve some problemsmuch faster than classical computers (in fact some problems that areintractable for classical computers may become trivial for quantumcomputers).

Shown in FIG. 1B is a simple example of a quantum computer configured tostore a qubit 122 and apply a single quantum gate operation 124 to thequbit 122. At time t0 the qubit 122 is described by α₁|0

+β₁|

at time t1 the logic operation 104 is applied to the qubit 122, and attime t2 the qubits 122 is described by α₂|0

+β₂|1

.

Unlike a classical bit, a qubit cannot be stored as a single voltagevalue on a wire. Instead, a qubit is physically realized using atwo-level quantum mechanical system. Many physical implementations ofqubits have been proposed and developed over the years with some beingmore promising than others. Some examples of leading qubitsimplementations include superconducting circuits, spin qubits, andtrapped ions.

It is the job of the quantum controller to generate the precise seriesof external signals, usually pulses of electromagnetic waves and pulsesof base band voltage, to perform the desired logic operations (and thuscarry out the desired quantum algorithm). Example implementations of aquantum controller are described in further detail below.

FIG. 2 shows an example quantum orchestration platform (QOP). The systemcomprises a quantum programming subsystem 202, a quantum controller 210,and a quantum processor 218.

The quantum programming subsystem 202 comprises circuitry operable togenerate a quantum algorithm description 206 which configures thequantum controller 210 and includes instructions the quantum controller210 can execute to carry out the quantum algorithm (i.e., generate thenecessary outbound quantum control pulse(s) 213) with little or no humanintervention during runtime. In an example implementation, the quantumprogramming system 202 is a personal computer comprising a processor,memory, and other associated circuitry (e.g., an ×86 or ×64 chipset)having installed on it a quantum orchestration software development kit(SDK) that enables creation (e.g., by a user via a text editor,integrated development environment (IDE), and/or by automated quantumalgorithm description generation circuitry) of a high-level (as opposedto binary or “machine code”) quantum algorithm description 206. In anexample implementation, the high-level quantum algorithm descriptionuses a high-level programming language (e.g., Python, R, Java, Matlab,etc.) simply as a “host” programming language in which are embedded theQOP programming constructs.

The high-level quantum algorithm description may comprise aspecification (an example of which is shown in FIGS. 10A-10C) and aprogram (an example program for a Power Rabi calibration is discussedbelow). Although the specification and program may be part of one ormore larger databases and/or contained in one or more files, and one ormore formats, the remainder of this disclosure will, for simplicity ofdescription, assume the configuration data structure and the programdata structure each takes the form of a plain-text file recognizable byan operating system (e.g., windows, Linux, Mac, or another OS) on whichquantum programming subsystem runs. The quantum programming subsystem202 then compiles the high-level quantum algorithm description 206 to amachine code version of the quantum algorithm description 206 (i.e.,series of binary vectors that represent instructions that the quantumcontroller's hardware can interpret and execute directly). An exampleimplementation of the data structures/vectors used for realizing themachine code version of the quantum algorithm description are describedbelow.

The quantum programming subsystem 202 is coupled to the quantumcontroller 210 via interconnect 204 which may, for example, utilizeuniversal serial bus (USB), peripheral component interconnect (PCIe)bus, wired or wireless Ethernet, or any other suitable communicationprotocol. The quantum controller 210 comprises circuitry operable toload the machine code quantum algorithm description 206 from theprogramming subsystem 202 via interconnect 204. Then, execution of themachine code by the quantum controller 210 causes the quantum controller210 to generate the necessary outbound quantum control pulse(s) 213 thatcorrespond to the desired operations to be performed on the quantumprocessor 218 (e.g., sent to qubit(s) for manipulating a state of thequbit(s) or to readout resonator(s) for reading the state of thequbit(s), etc.). Depending on the quantum algorithm to be performed,outbound pulse(s) 213 for carrying out the algorithm may bepredetermined at design time and/or may need to be determined duringruntime. The runtime determination of the pulses may compriseperformance of classical calculations and processing in the quantumcontroller 210 and/or the quantum programing subsystem 202 duringruntime of the algorithm (e.g., runtime analysis of inbound pulses 215received from the quantum processor 218).

During runtime and/or upon completion of a quantum algorithm performedby the quantum controller 210, the quantum controller 210 may outputdata/results 208 to the quantum programming subsystem 202. In an exampleimplementation these results may be used to generate a new quantumalgorithm description 206 for a subsequent run of the quantum algorithmand/or update the quantum algorithm description during runtime.

The quantum controller 210 is coupled to the quantum processor 218 viainterconnect 212 which may comprise, for example, one or more conductorsand/or optical fibers. The quantum controller 210 may comprise aplurality of interconnected, but physically distinct quantum controlmodules (e.g., each module being a desktop or rack mounted device) suchthat quantum control systems requiring relatively fewer resources can berealized with relatively fewer quantum control modules and quantumcontrol systems requiring relatively more resources can be realized withrelatively more quantum control modules.

The quantum processor 218 comprises K (an integer) quantum elements 122,which includes qubits (which could be of any type such assuperconducting, spin qubits, ion trapped, etc.), and, where applicable,any other element(s) for processing quantum information, storing quantuminformation (e.g. storage resonator), and/or coupling the outboundquantum control pulses 213 and inbound quantum control pulses 215between interconnect 212 and the quantum element(s) 122 (e.g., readoutresonator(s)). In an example implementation in which the quantumprocessor comprises readout resonators (or other readout circuitry), Kmay be equal to the total number of qubits plus the number of readoutcircuits. That is, if each of Q (an integer) qubits of the quantumprocessor 218 is associated with a dedicated readout circuit, then K maybe equal to 2Q. For ease of description, the remainder of thisdisclosure will assume such an implementation, but it need not be thecase in all implementations. Other elements of the quantum processor 218may include, for example, flux lines (electronic lines for carryingcurrent), gate electrodes (electrodes for voltage gating),current/voltage lines, amplifiers, classical logic circuits residingon-chip in the quantum processor 218, and/or the like.

FIG. 3A shows an example quantum controller architecture in accordancewith various example implementations of this disclosure. The quantumcontroller 210 comprises L (an integer ≥1) pulser circuits 302 ₀-302_(L−1) and shared circuitry 310.

In the example implementation shown, each pulser circuit 302 _(l) (l aninteger between 0 and L−1) comprises circuitry for exchanginginformation over signal paths 304 _(l), 306 _(l), and 308 _(l), wherethe signal path 308 _(l) carries outbound pulses (e.g., 213 of FIG. 2 )generated by the pulser circuit 302 _(l) (which may be, for example,control pulses sent to the quantum processor 218 to manipulate one ormore properties of one or more quantum elements—e.g., manipulate a stateof one or more qubits, manipulate a frequency of a qubit using fluxbiasing, etc., and/or readout a state of one or more quantum elements),the signal path 306 _(l) carries inbound quantum element readout pulses(e.g., 215 of FIG. 2 ) to be processed by the pulser circuit 302 _(l),and signal path 304 _(l) carries control information. Each signal pathmay comprise one or more conductors, optical channels, and/or wirelesschannels.

Each pulser circuit 302 _(l) comprises circuitry operable to generateoutbound pulses on signal path 308 _(l) according to quantum controloperations to be performed on the quantum processor 218. This involvesvery precisely controlling characteristics such as phase, frequency,amplitude, and timing of the outbound pulses. The characteristics of anoutbound pulse generated at any particular time may be determined, atleast in part, on inbound pulses received from the quantum processor 218(via shared circuitry 310 and signal path 306 _(l)) at a prior time. Inan example implementation, the time required to close the feedback loop(i.e., time from receiving a first pulse on one or more of paths 315₁-315 _(L) (e.g., at an analog to digital converter of the path) tosending a second pulse on one or more of paths 313 ₀-313 _(L−1), (e.g.,at an output of a digital-to-analog converter of the path), where thesecond pulse is based on the first pulse, is significantly less than thecoherence time of the qubits of the quantum processor 218. For example,the time to close the feedback loop may be on the order of 100nanoseconds. It should be noted that each signal path in FIG. 3A may inpractice be a set of signal paths for supporting generation ofmulti-pulse sets (e.g., two signal paths for two-pulse pairs, threesignal paths for three-pulse sets, and so on).

In the example implementation shown, the shared circuitry 310 comprisescircuitry for exchanging information with the pulser circuits 302 ₀-302_(L−1) over signal paths 304 ₀-304 _(L−1), 306 ₀-306 _(L−1), and 308₀-308 _(L−1), where each signal path 308 _(l) carries outbound pulsesgenerated by the pulser circuit 302 _(l), each signal path 306 _(l)carries inbound pulses to be processed by pulser circuit 302 _(l), andeach signal path 304 _(l) carries control information such asflag/status signals, data read from memory, data to be stored in memory,data streamed to/from the quantum programming subsystem 202, and data tobe exchanged between two or more pulsers 302 ₀-302 _(L). Similarly, inthe example shown the shared circuitry 310 comprises circuitry forexchanging information with the quantum processor 218 over signal paths315 ₀-315 _(M-1) and 313 ₁-313 _(K−1), where each signal path 315 _(m)(m an integer between 0 and M−1) carries inbound pulses from the quantumprocessor 218, and each signal path 313 _(k) (k an integer between 0 andK−1) carries outbound pulses to the quantum processor 218. Additionally,in the example shown the shared circuitry 310 comprises circuitry forexchanging information with the quantum programming subsystem oversignal path 311. The shared circuitry 310 may be: integrated with thequantum controller 210 (e.g., residing on one or more of the same fieldprogrammable gate arrays or application specific integrated circuits orprinted circuit boards); external to the quantum controller (e.g., on aseparate FPGA, ASIC, or PCB connected to the quantum controller via oneor more cables, backplanes, or other devices connected to the quantumprocessor 218, etc.); or partially integrated with the quantumcontroller 210 and partially external to the quantum controller 210.

In various implementations, M may be less than, equal to, or greaterthan L, K may be less than, equal to, or greater than L, and M may beless than, equal to, or greater than K. For example, the nature of somequantum algorithms is such that not all K quantum elements need to bedriven at the same time. For such algorithms, L may be less than K andone or more of the L pulsers 302 _(l) may be shared among multiple ofthe K quantum elements circuits. That is, any pulser 302 _(l) maygenerate pulses for different quantum elements at different times. Thisability of a pulser 302 _(l) to generate pulses for different quantumelements at different times can reduce the number of pulsers 302 ₀-302_(L−1) (i.e., reduce L) required to support a given number of quantumelements (thus saving significant resources, cost, size, overhead whenscaling to larger numbers of qubits, etc.).

The ability of a pulser 302 _(l) to generate pulses for differentquantum elements at different times also enables reduced latency. Asjust one example, assume a quantum algorithm which needs to send a pulseto quantum element 122 ₀ at time T1, but whether the pulse is to be of afirst type or second type (e.g., either an X pulse or a Hadamard pulse)cannot be determined until after processing an inbound readout pulse attime T1-DT (i.e., DT time intervals before the pulse is to be output).If there were a fixed assignment of pulsers 302 ₀-302 _(L−1) to quantumelements of the quantum processor 218 (i.e., if 302 ₀ could only sendpulses to quantum element 122 ₀, and pulser 302 ₁ could only send pulsesto quantum element 1221, and so on), then pulser 302 ₀ might not be ableto start generating the pulse until it determined what the type was tobe. In the depicted example implementation, on the other hand, pulser302 ₀ can start generating the first type pulse and pulser 302 ₁ canstart generating the second type pulse and then either of the two pulsescan be released as soon as the necessary type is determined. Thus, ifthe time to generate the pulse is T_(lat), in this example the examplequantum controller 210 may reduce latency of outputting the pulse byT_(lat).

The shared circuitry 310 is thus operable to receive pulses via any oneor more of the signals paths 308 ₀-308 _(L−1) and/or 315 ₀-315 _(M-1),process the received pulses as necessary for carrying out a quantumalgorithm, and then output the resulting processed pulses via any one ormore of the signal paths 306 ₀-306 _(L−1) and/or 313 ₀-313 _(K−1). Theprocessing of the pulses may take place in the digital domain and/or theanalog domain. The processing may comprise, for example: frequencytranslation/modulation, phase translation/modulation, frequency and/ortime division multiplexing, time and/or frequency divisiondemultiplexing, amplification, attenuation, filtering in the frequencydomain and/or time domain, time-to-frequency-domain orfrequency-to-time-domain conversion, upsampling, downsampling, and/orany other signal processing operation. At any given time, the decisionas to from which signal path(s) to receive one or more pulse(s), and thedecision as to onto which signal path(s) to output the pulse(s) may be:predetermined (at least in part) in the quantum algorithm description;and/or dynamically determined (at least in part) during runtime of thequantum algorithm based on classical programs/computations performedduring runtime, which may involve processing of inbound pulses. As anexample of predetermined pulse generation and routing, a quantumalgorithm description may simply specify that a particular pulse withpredetermined characteristics is to be sent to signal path 313 ₁ at apredetermined time. As an example of dynamic pulse determination androuting, a quantum algorithm description may specify that an inboundreadout pulse at time T-DT should be analyzed and its characteristics(e.g., phase, frequency, and/or amplitude) used to determine, forexample, whether at time T pulser 302 _(l) should output a pulse to afirst quantum element or to a second quantum element or to determine,for example, whether at time T pulser 302 _(l) should output a firstpulse to a first quantum element or a second pulse to the first quantumelement. In various implementations of the quantum controller 210, theshared circuitry 310 may perform various other functions instead ofand/or in addition to those described above. In general, the sharedcircuitry 310 may perform functions that are desired to be performedoutside of the individual pulser circuits 302 ₀-302 _(L−1). For example,a function may be desirable to implement in the shared circuitry 310where the same function is needed by a number of pulser circuits from302 ₀-302 _(L−1) and thus may be shared among these pulser circuitsinstead of redundantly being implemented inside each pulser circuit. Asanother example, a function may be desirable to implement in the sharedcircuitry 310 where the function is not needed by all pulser circuits302 ₀-302 _(L−1) at the same time and/or on the same frequency and thusfewer than L circuits for implementing the function may be shared amongthe L pulser circuits 302 ₀-302 _(L−1) through time and/or frequencydivision multiplexing. As another example, a function may be desirableto implement in the shared circuitry 310 where the function involvesmaking decisions based on inputs, outputs, and/or state of multiple ofthe L pulser circuits 302 ₀-302 _(L−1), or other circuits. Utilizing acentralized coordinator/decision maker in the shared circuitry 310 mayhave the benefit(s) of: (1) reducing pinout and complexity of the pulsercircuits 302 ₀-302 _(L−1); and/or (2) reducing decision-making latency.Nevertheless, in some implementations, decisions affecting multiplepulser circuits 302 ₀-302 _(L−1) may be made by one or more of thepulser circuits 302 ₀-302 _(L−1) where the information necessary formaking the decision can be communicated among pulser circuits within asuitable time frame (e.g., still allowing the feedback loop to be closedwithin the qubit coherence time) over a tolerable number of pins/traces.

FIG. 3B shows an example implementation of the quantum controller ofFIG. 2 . The example quantum controller shown comprises pulsers 302₁-302 _(L−1), receive analog frontend 350, input manager 352, digitalmanager 354, pulse operations manager 356, pulse operations 358, outputmanager 360, transmit analog frontend 362, data exchange 364,synchronization manager 366, and input/output (“I/O”) manager 368.Circuitry depicted in FIG. 3B other than pulser circuits 302 ₀-302_(L−1) corresponds to an example implementation of the shared circuitry310 of FIG. 3A.

The receive analog frontend 350 comprises circuitry operable toconcurrently process up to M (an integer ≥1) analog inbound signals(RP′₀-RP′_(M-1)) received via signal paths 315 ₀-315 _(M-1) to generateup to M concurrent inbound signals (RP₀-RP_(M-1)) to be output to inputmanager 352 via one or more signal paths. Although there is shown to beM signals RP and M signals RP′, this need not be the case. Suchprocessing may comprise, for example, analog-to-digital conversion,filtering, upconversion, downconversion, amplification, attenuation,time division multiplexing/demultiplexing, frequency divisionmultiplexing/demultiplexing, and/or the like. In variousimplementations, M may be less than, equal to, or greater than L and Mmay be less than, equal to, or greater than K.

The input manager 352 comprises circuitry operable to route any one ormore of signals (RP₀-RP_(M-1)) to any one or more of pulsers 302 ₀-302_(L−1) (as signal(s) AI₀-AI_(L−1)) and/or to other circuits (e.g. assignal io_mgr to I/O manager 368). In an example implementation, theinput manager 352 comprises one or more switch networks, multiplexers,and/or the like for dynamically reconfiguring which signals RP₀-RP_(M-1)are routed to which pulsers 302 ₀-302 _(L−1). This may enable timedivision multiplexing multiple of the signals RP₀-RP_(M-1) onto a singlesignal AI_(l) and/or time division demultiplexing components (e.g., timeslices) of a signal RP_(m) onto multiple of the signals AI₀-AI_(L−1). Inan example implementation, the input manager 352 comprises one or moremixers and/or filters for frequency division multiplexing multiple ofthe signals RP₀-RP_(M-1) onto a single signal AI_(l) and/or frequencydivision demultiplexing components (e.g., frequency bands) of a signalRP_(m) onto multiple of the signals AI₀-AI_(L−1). The signal routing andmultiplexing/demultiplexing functions performed by the input manager 352enables: a particular pulser 302 _(l) to process different inboundpulses from different quantum elements at different times; a particularpulser 302 _(l) to process different inbound pulses from differentquantum elements at the same time; and multiple of the pulsers 302 ₀-302_(L−1) to processes the same inbound pulse at the same time. In theexample implementation shown, routing of the signals RP₀-RP_(M-1) amongthe inputs of the pulsers 302 ₀-302 _(L−1) is controlled by digitalcontrol signals in_slct₀-in_slct_(L−1) from the pulsers 302 ₀-302_(L−1). In another implementation, the input manager may be operable toautonomously determine the appropriate routing (e.g., where the quantumalgorithm description includes instructions to be loaded into memory of,and executed by, the input manager 352). In the example implementation,the input manager 352 is operable to rout input signals RP₀-RP_(M-1) tothe I/O manager 368 (as signal(s) io_mgr), to be sent to the quantumprograming subsystem 202. This routing may, for example, be controlledby signals from the digital manager 354. In an example implementation,for each input signal RP_(m) there is a digital signal, stream_(m), fromthe digital manager 354 to the input manager 352 that controls whetherRP_(m) will be sent from the input manager 352 to the I/O manager 368and from there to the quantum programing subsystem 202.

Each of the pulsers 302 ₀-302 _(L−1) is as described above withreference to FIG. 3A. In the example implementation shown, each pulser302 _(l) is operable to generate raw outbound pulses CP′_(l) (“raw” isused simply to denote that the pulse has not yet been processed by pulseoperations circuitry 358) and digital control signals in_slct_(l),D_port_(l), D_(l), out_slct_(l), ops_ctrl_(l), ops_slct_(l), IF_(l),F_(l), and dmod_sclt_(l) for carrying out quantum algorithms on thequantum processor 218, and results_(l) for carrying intermediate and/orfinal results generated by the pulser 302 _(l) to the quantumprogramming subsystem 202. One or more of the pulsers 302 ₀-302 _(L−1)may receive and/or generate additional signals which are not shown inFIG. 3A for clarity of illustration. The raw outbound pulsesCP′₀-CP′_(L−1) are conveyed via signal paths 308 ₀-308 _(L−1) and thedigital control signals are conveyed via signal paths 304 ₀-304 _(L−1).Each of the pulsers 302 _(l) is operable to receive inbound pulse signalAI_(l) and signal f_dmod_(l). Pulser 302 _(l) may process the inboundsignal AI_(l) to determine the state of certain quantum element(s) inthe quantum processor 218 and use this state information for makingdecisions such as, for example, which raw outbound pulse CP′_(l) togenerate next, when to generate it, and what control signals to generateto affect the characteristics of that raw outbound pulse appropriately.Pulser 302 _(l) may use the signal f_dmod_(l) for determining how toprocess inbound pulse signal AI_(l). As an example, when pulser 302 ₁needs to process an inbound signal AI₁ from quantum element 122 ₃, itcan send a dmod_sclt_(l) signal that directs pulse operations manager356 to send, on f_dmod₁, settings to be used for demodulation of aninbound signal AI₁ from quantum element 122 ₃ (e.g., the pulseoperations manager 356 may send the value cos(ω₃*TS*T_(clk1)+ϕ₃), whereω₃ is the frequency of quantum element 122 ₃, TS is amount of timepassed since the reference point, for instance the time at which quantumalgorithm started running, and ϕ₃ is the phase of the total framerotation of quantum element 122 ₃, i.e. the accumulated phase of allframe rotations since the reference point).

The pulse operations circuitry 358 is operable to process the rawoutbound pulses CP′₀-CP′_(L−1) to generate corresponding output outboundpulses CP₀-CP_(L−1). This may comprise, for example, manipulating theamplitude, phase, and/or frequency of the raw pulse CP′_(l). The pulseoperations circuitry 358 receives raw outbound pulses CP′₀-CP′_(L−1)from pulsers 302 ₀-302 _(L−1), control signals ops_cnfg₀-ops_cnfg_(L−1)from pulse operations manager 356, and ops_ctrl₀-ops_ctrl_(L−1) frompulsers 302 ₀-302 _(L−1).

The control signal ops_cnfg_(l) configures, at least in part, the pulseoperations circuitry 358 such that each raw outbound pulse CP′_(l) thatpasses through the pulse operations circuitry 358 has performed on itone or more operation(s) tailored for that particular pulse. Toillustrate, denoting a raw outbound pulse from pulser 302 ₃ at time T1as CP′_(3,T1), then, at time T1 (or sometime before T1 to allow forlatency, circuit setup, etc.), the digital control signal ops_cnfg₃(denoted ops_cnfg_(3,T1) for purposes of this example) provides theinformation (e.g., in the form of one or more matrix, as describedbelow) as to what specific operations are to be performed on pulseCP′_(3,T1). Similarly, ops_cnfg_(4,T1) provides the information as towhat specific operations are to be performed on pulse CP′_(4,T1), andops_cnfg_(3,T2) provides the information as to what specific operationsare to be performed on pulse CP′_(4,T1).

The control signal ops_ctrl_(l) provides another way for the pulser 302_(l) to configure how any particular pulse is processed in the pulseoperations circuitry 358. This may enable the pulser 302 _(l) to, forexample, provide information to the pulse operation circuitry 358 thatdoes not need to pass through the pulse operation manager 356. Forexample, the pulser 302 _(l) may send matrix values calculated inreal-time by the pulser 302 _(l) to be used by the pulse operationcircuitry 358 to modify pulse CP′_(l). These matrix values arrive to thepulse operation circuitry 358 directly from the pulser 302 _(l) and donot need to be sent to the pulse operation manager first. Anotherexample may be that the pulser 302 _(l) provides information to thepulse operation circuitry 358 to affect the operations themselves (e.g.the signal ops_ctrl_(l) can choose among several different mathematicaloperations that can be performed on the pulse).

The pulse operations manager 356 comprises circuitry operable toconfigure the pulse operations circuitry 358 such that the pulseoperations applied to each raw outbound pulse CP′_(l) are tailored tothat particular raw outbound pulse. To illustrate, denoting a first rawoutbound pulse to be output during a first time interval T1 asCP′_(l,T1), and a second raw outbound pulse to be output during a secondtime interval T2 as CP′_(l,T2), then pulse operations circuitry 358 isoperable to perform a first one or more operations on CP′_(l,T1) and asecond one or more operations on CP′_(1,T2). The first one or moreoperations may be determined, at least in part, based on to whichquantum element the pulse CP_(1,T1) is to be sent, and the second one ormore operations may be determined, at least in part, based on to whichquantum element the pulse CP_(1,T2) is to be sent. The determination ofthe first one or more operations and second one or more operations maybe performed dynamically during runtime.

The transmit analog frontend 362 comprises circuitry operable toconcurrently process up to K digital signals DO_(k) to generate up to Kconcurrent analog signals AO_(k) to be output to the quantum processor218. Such processing may comprise, for example, digital-to-analogconversion, filtering, upconversion, downconversion, amplification,attenuation, time division multiplexing/demultiplexing, frequencydivision multiplexing/demultiplexing and/or the like. In an exampleimplementation, each of the one or more of signal paths 313 ₀-313 _(K−1)(FIG. 3A) represents a respective portion of Tx analog frontend circuit362 as well as a respective portion of interconnect 212 (FIG. 2 )between the Tx analog frontend circuit 362 and the quantum processor218. Although there is one-to-one correspondence between the number ofDO signals and the number of AO signals in the example implementationdescribed here, such does not need to be the case. In another exampleimplementation, the analog frontend 362 is operable to map more (orfewer) signals DO to fewer (or more) signals AO. In an exampleimplementation the transmit analog frontend 362 is operable to processdigital signals DO₀-DO_(K−1) as K independent outbound pulses, as K/2two-pulse pairs, or process some of signals DO₀-DO_(K−1) as independentoutbound pulses and some signals DO₀-DO_(K−1) as two-pulse pairs (atdifferent times and/or concurrently.

The output manager 360 comprises circuitry operable to route any one ormore of signals CP₀-CP_(L−1) to any one or more of signal paths 313₀-313 _(K−1). As just one possible example, signal path 313 ₀ maycomprise a first path through the analog frontend 362 (e.g., a firstmixer and DAC) that outputs AO₀ and traces/wires of interconnect 212that carry signal AO₀; signal path 313 ₁ may comprise a second paththrough the analog frontend 362 (e.g., a second mixer and DAC) thatoutputs AO₁ and traces/wires of interconnect 212 that carry signal AO₁,and so on. In an example implementation, the output manager 360comprises one or more switch networks, multiplexers, and/or the like fordynamically reconfiguring which one or more signals CP₀-CP_(L−1) arerouted to which signal paths 313 ₀-313 _(K−1). This may enable timedivision multiplexing multiple of the signals CP₀-CP_(L−1) onto a singlesignal path 313 _(k) and/or time division demultiplexing components(e.g., time slices) of a signal CP_(m) onto multiple of the signal paths313 ₀-313 _(K−1). In an example implementation, the output manager 360comprises one or more mixers and/or filters for frequency divisionmultiplexing multiple of the signals CP₀-CP_(M-1) onto a single signalpath 313 _(k) and/or frequency division demultiplexing components (e.g.,frequency bands) of a signal CP_(m) onto multiple of the signal paths313 ₀-313 _(K−1). The signal routing and multiplexing/demultiplexingfunctions performed by the output manager 360 enables: routing outboundpulses from a particular pulser 302 _(l) to different ones of the signalpaths 313 ₀-313 _(K−1) at different times; routing outbound pulses froma particular pulser 302 _(l) to multiple of the signal paths 313 ₀-313_(K−1) at the same time; and multiple of the pulsers 302 ₀-302 _(L−1)generating pulses for the same signal path 313 _(k) at the same time. Inthe example implementation shown, routing of the signals CP₀-CP_(L−1)among the signal paths 313 ₀-313 _(K−1) is controlled by digital controlsignals out_slct₀-out_slct_(L−1) from the pulsers 302 ₀-302 _(L−1). Inanother implementation, the output manager 360 may be operable toautonomously determine the appropriate routing (e.g., where the quantumalgorithm description includes instructions to be loaded into memory of,and executed by, the output manager 360). In an example implementation,at any given time, the output manager 360 is operable to concurrentlyroute K of the digital signals CP₀-CP_(L−1) as K independent outboundpulses, concurrently route K/2 of the digital signals CP₀-CP_(L−1) astwo-pulse pairs, or route some of signals CP₀-CP_(L−1) as independentoutbound pulses and some others of the signals CP₀-CP_(L−1) asmulti-pulse sets (at different times and/or concurrently).

The digital manager 354 comprises circuitry operable to process and/orroute digital control signals (DigCtrl₀-DigCtrl_(J−1)) to variouscircuits of the quantum controller 210 and/or external circuits coupledto the quantum controller 210. In the example implementation shown, thedigital manager receives, from each pulser 302 _(l), (e.g., via one ormore of signal paths 304 ₀-304 _(N-1)) a digital signal Di that is to beprocessed and routed by the digital manager 354, and a control signalD_port_(l) that indicates to which output port(s) of the digital manager354 the signal Di should be routed. The digital control signals may berouted to, for example, any one or more of circuits shown in FIG. 3B,switches/gates which connect and disconnect the outputs AO₀-AO_(K−1)from the quantum processor 218, external circuits coupled to the quantumcontroller 210 such as microwave mixers and amplifiers, and/or any othercircuitry which can benefit from on real-time information from thepulser circuits 302 ₀-302 _(L−1). Each such destination of the digitalsignals may require different operations to be performed on the digitalsignal (such as delay, broadening, or digital convolution with a givendigital pattern). These operations may be performed by the digitalmanager 354 and may be specified by control signals from the pulsers 302₀-302 _(L−1). This allows each pulser 302 _(l) to generate digitalsignals to different destinations and allows different ones of pulsers302 ₀-302 _(L−1) to generate digital signals to the same destinationwhile saving resources.

The synchronization manager 366 comprises circuitry operable to managesynchronization of the various circuits shown in FIG. 3B. Suchsynchronization is advantageous in a modular and dynamic system, such asquantum controller 210, where different ones of pulsers 302 ₀-302 _(L−1)generate, receive, and process pulses to and from different quantumelements at different times. For example, while carrying out a quantumalgorithm, a first pulser circuit 302 ₁ and a second pulser circuit 302₂ may sometimes need to transmit pulses at precisely the same time andat other times transmit pulses independently of one another. In theexample implementation shown, the synchronization manager 366 reducesthe overhead involved in performing such synchronization.

The data exchange circuitry 364 is operable to manage exchange of dataamong the various circuits shown in FIG. 3B. For example, while carryingout a quantum algorithm, a first pulser circuit 302 ₁ and a secondpulser circuit 302 ₂ may sometimes need to exchange information. As justone example, pulser 302 ₁ may need to share, with pulser 302 ₂, thecharacteristics of an inbound signal AI₁ that it just processed so thatpulser 302 ₂ can generate a raw outbound pulse CP′₂ based on thecharacteristics of AI₁. The data exchange circuitry 364 may enable suchinformation exchange. In an example implementation, the data exchangecircuitry 364 may comprise one or more registers to and from which thepulsers 302 ₀-302 _(L−1) can read and write.

The I/O manager 368 is operable to route information between the quantumcontroller 210 and the quantum programming subsystem 202. Machine codequantum algorithm descriptions may be received via the I/O manager 368.Accordingly, the I/O manager 368 may comprise circuitry for loading themachine code into the necessary registers/memory (including any SRAM,DRAM, FPGA BRAM, flash memory, programmable read only memory, etc.) ofthe quantum controller 210 as well as for reading contents of theregisters/memory of the quantum controller 210 and conveying thecontents to the quantum programming subsystem 202. The I/O manager 368may, for example, include a PCIe controller, AXIcontroller/interconnect, and/or the like.

FIG. 4 shows an example implementation of the pulser of FIG. 3B. Theexample pulser 302 _(l) shown comprises instruction memory 402, pulsetemplate memory 404, digital pattern memory 406, control circuitry 408,and compute and/or signal processing circuitry (CSP) 410.

The memories 402, 404, 406 may comprise one or more be any type ofsuitable storage elements (e.g., DRAM, SRAM, Flash, etc.). Theinstructions stored in memory 402 are instructions to be executed out bythe pulser 302 _(l) for carrying out its role in a quantum algorithm.Because different pulsers 302 ₀-302 _(L−1) have different roles to playin any particular quantum algorithm (e.g., generating different pulsesat different times), the instructions memory 402 for each pulser 302_(l) may be specific to that pulser. For example, the quantum algorithmdescription 206 from the quantum programming subsystem 202 may comprisea first set of instructions to be loaded (via I/O manager 368) intopulser 302 ₀, a second set of instructions to be loaded into pulser 302₁, and so on. Each pulse template stored in memory 404 comprises asequence of one or more samples of any arbitrary shape (e.g., Gaussian,sinc, impulse, etc.) representing the pulses to be sent to pulseoperation circuitry 358. Each digital pattern stored in memory 406comprises a sequence of one or more binary values which may representthe digital pulses to be sent to the digital manager 354 for generatingdigital control signals DigCtrl₀-DigCtrl_(J−1).

The control circuitry 408 is operable to execute the instructions storedin memory 402 to process inbound signal AI_(l), generate raw outboundpulses CP′_(l), and generate digital control signals in_slct_(l),out_slct_(l), D_port_(l), D_(l), IF_(l), F_(l), ops_slct_(l),ops_ctrl_(l), results_(l), dmod_slct_(l) and pair_(l). In the exampleimplementation shown, the processing of the inbound signal AI_(l) isperformed by the CSP circuitry 410 and based (at least in part) on thesignal f_dmod_(l).

The compute and/or signal processing circuitry (CSP) 410 is operable toperform computational and/or signal processing functions, which maycomprise, for example Boolean-algebra based logic and arithmeticfunctions and demodulation (e.g., of inbound signals AI_(l)). The CSP410 may comprise memory in which are stored instructions for performingthe functions and demodulation. The instructions may be specific to aquantum algorithm to be performed and be generated during compilation ofa quantum machine specification and QUA program.

In operation of an example implementation, generation of a raw outboundpulse CP′_(l) comprises the control circuitry 408: (1) determining apulse template to retrieve from memory 404 (e.g., based on a result ofcomputations and/or signal processing performed by the CSP 410); (2)retrieving the pulse template; (3) performing some preliminaryprocessing on the pulse template; (4) determining the values of F, IF,pair_(l), ops_slct_(l), and dmod_slct_(l) to be sent to the pulseoperation manager 356 (as predetermined in the quantum algorithmdescription and/or determined dynamically based on results ofcomputations and/or signal processing performed by the CSP 410); (5)determining the value of ops_ctrl_(l) to be sent to the pulse operationcircuitry 358; (6) determining the value of in_slct_(l) to be sent tothe input manager 352; (7) determining a digital pattern to retrievefrom memory 406 (as predetermined in the quantum algorithm descriptionand/or determined dynamically based on results of computations and/orsignal processing performed by the CSP 410); (8) outputting the digitalpattern as Di to the digital manager along with control signalD_port_(l) (as predetermined in the quantum algorithm description and/ordetermined dynamically based on results of computations and/or signalprocessing performed by the CSP 410); (9) outputting the raw outboundpulse CP′_(l) to the pulse operations circuitry 358; (10) outputtingresults_(l) to the I/O manager.

FIG. 5 shows an example implementation of the pulse operations managerand pulse operations circuitry of FIG. 3B. The pulse operationscircuitry 358 comprises a plurality of pulse modification circuits 508₀-508 _(R-1) (R is an integer ≥1 in general, and R=L/2 in the exampleshown). The pulse operations manager 356 comprises control circuitry502, routing circuitry 506, and a plurality of modification settingscircuits 504 ₀-504 _(K−1).

Although the example implementation has a 1-to-2 correspondence betweenpulse modification circuits 508 ₀-508 _(R-1) and pulser circuits 302₀-302 _(L−1), such does not need to be the case. In otherimplementations there may be fewer pulse modification circuits 508 thanpulser circuits 302. Similarly, other implementations may comprise morepulse modification circuits 508 than pulser circuits 302.

As an example, in some instances, two of the pulsers 302 ₀-302 _(L−1)may generate two raw outbound pulses which are a phase-quadrature pulsepair. For example, assuming CP₁ and CP₂ are a phase-quadrature pulsepair to be output on path 313 ₃. In this example, pulse operationscircuitry 358 may process CP₁ and CP₂ by multiplying a vectorrepresentation of CP′₁ and CP′₂ by one or more 2 by 2 matrices to: (1)perform single-sideband-modulation, as given by

$\begin{matrix}{{\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}{\cos\left( {\omega*{TS}*T_{{clck}1}} \right)} & {{- \sin}\left( {\omega*{TS}*T_{clck1}} \right)} \\{\sin\left( {\omega*{TS}*T_{clck1}} \right)} & {\cos\left( {\omega*{TS}*T_{clck1}} \right)}\end{pmatrix}\begin{pmatrix}{CP}_{1}^{\prime} \\{CP}_{2}^{\prime}\end{pmatrix}}},} & \end{matrix}$where ω is the frequency of the single side band modulation and TS isthe time passed since the reference time (e.g. the beginning of acertain control protocol); (2) keep track of frame-of-referencerotations, as given by

${\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}{\cos(\phi)} & {{- \sin}(\beta)} \\{\sin(\phi)} & {\cos(\phi)}\end{pmatrix}\begin{pmatrix}{CP}_{1}^{\prime} \\{CP}_{2}^{\prime}\end{pmatrix}}},$where ϕ is the total phase that the frame of reference accumulated sincethe reference time; and/or (3) perform an IQ-mixer correction

$\begin{matrix}{{\begin{pmatrix}{CP_{1}} \\{CP_{2}}\end{pmatrix} = {\begin{pmatrix}C_{00} & C_{01} \\C_{10} & C_{11}\end{pmatrix}\begin{pmatrix}{CP}_{1}^{\prime} \\{CP}_{2}^{\prime}\end{pmatrix}}},} & \end{matrix}$where C₀₀, C₀₁, C₁₀, and C₁₁ are the elements of a matrix that correctsfor IQ-mixer imperfections. In an example implementation, eachmodification settings circuit, 504 _(k), contains registers that containthe matrix elements of three matrices:

${C_{k} = \begin{pmatrix}C_{k00} & C_{k01} \\C_{k10} & C_{k11}\end{pmatrix}},$an IQ-mixer correction matrix;

${S_{k} = \begin{pmatrix}{\cos\left( {\omega_{k}*TS*T_{clck1}} \right)} & {{- \sin}\left( {\omega_{k}*TS} \right)*T_{clck1}} \\{\sin\left( {\omega_{k}*TS*T_{clck1}} \right)} & {\cos\left( {\omega_{k}*TS*T_{clckl}} \right)}\end{pmatrix}},$a single side band frequency modulation matrix; and

${F_{k} = \begin{pmatrix}{\cos\left( \phi_{k} \right)} & {{- \sin}\left( \phi_{k} \right)} \\{\sin\left( \phi_{k} \right)} & {\cos\left( \phi_{k} \right)}\end{pmatrix}},$a frame rotation matrix, which rotates the IQ axes around the axisperpendicular to the IQ plane (i.e. the z-axis if I and Q are the x-axisand y-axis). In an example implementation, each modification settingscircuit 504 _(k) also contains registers that contain the elements ofthe matrix products C_(k)S_(k)F_(k) and S_(k)F_(k).

In the example shown, each pulse modification circuit 508 _(r) isoperable to process two raw outbound pulses CP′_(2r) and CP′_(2r+1)according to: the modification settings ops_cnfg_(2r) andops_cnfg_(2r+1); the signals ops_ctrl_(2r) and ops_ctrl_(2r+1); and thesignals pair_(2r) and pair_(2r+1). In an example implementationpair_(2r) and pair_(2r+1) may be communicated as ops_ctrl_(2r) andops_ctrl_(2r+1). The result of the processing is outbound pulses CP_(2r)and CP_(2r+1). Such processing may comprise adjusting a phase,frequency, and/or amplitude of the raw outbound pulses CP′_(2r) andCP′_(2r+1). In an example implementation, ops_cnfg_(2r) andops_cnfg_(2r+1) are in the form of a matrix comprising real and/orcomplex numbers and the processing comprises matrix multiplicationinvolving a matrix representation of the raw outbound pulses CP_(2r) andCP_(2r+1) and the ops_cnfg_(2r) and ops_cnfg_(2r+1) matrix.

The control circuitry 502 is operable to exchange information with thepulser circuits 302 ₀-302 _(L−1) to generate values ofops_confg₀-ops_confg_(L−1) and f_demod₀-f_demod_(L−1), to controlrouting circuitry 506 based on signals ops_slct₀-ops_slct_(L−1) anddmod_slct₀-dmod_slct_(L−1), and to update pulse modification settings504 ₀-504 _(K−1) based on IF₀-IF_(L−1) and F₀-F_(L−1) such that pulsemodification settings output to pulse operations circuitry 358 arespecifically tailored to each raw outbound pulse (e.g., to which quantumelement 222 the pulse is destined, to which signal path 313 the pulse isdestined, etc.) to be processed by pulse operations circuitry 358.

Each modification settings circuit 504 _(k) comprises circuitry operableto store modification settings for later retrieval and communication tothe pulse operations circuitry 358. The modification settings stored ineach modification settings circuit 504 _(k) may be in the form of one ormore two-dimensional complex-valued matrices. Each signal path 313 ₀-313_(K−1) may have particular characteristics (e.g., non-idealities ofinterconnect, mixers, switches, attenuators, amplifiers, and/or circuitsalong the paths) to be accounted for by the pulse modificationoperations. Similarly, each quantum element 122 ₀-122 _(k) may have aparticular characteristics (e.g. resonance frequency, frame ofreference, etc.). In an example implementation, the number of pulsemodification settings, K, stored in the circuits 504 corresponds to thenumber of quantum element 122 ₀-122 _(K−1) and of signal paths 313 ₀-313_(K−1) such that each of the modification settings circuits 504 ₀-504_(K−1) stores modification settings for a respective one of the quantumelements 122 ₀-122 _(K−1) and/or paths 313 ₀-313 _(K−1). In otherimplementations, there may be more or fewer pulse modification circuits504 than signal paths 313 and more or fewer pulse modification circuits504 than quantum elements 122 and more or fewer signal paths 313 thanquantum elements 122. The control circuitry 502 may load values into themodification settings circuit 504 ₀-504 _(K−1) via signal 503.

The routing circuitry 506 is operable to route modification settingsfrom the modification settings circuits 504 ₀-504 _(L−1) to the pulseoperations circuit 358 (as ops_confg₀-ops_confg_(L−1)) and to thepulsers 302 ₀-302 _(L−1) (as f_dmod₀-f_dmod_(L−1)). In the exampleimplementation shown, which of the modification settings circuits 504₀-504 _(K−1) has its/their contents sent to which of the pulsemodification circuits 508 ₀-508 _(R-1) and to which of the pulsers 302₀-302 _(L−1) is controlled by the signal 505 from the control circuitry502.

The signal ops_slct_(l) informs the pulse operations manager 356 as towhich modification settings 504 _(k) to send to the pulse modificationcircuit 5081. The pulser 302 _(l) may determine ops_slct_(l) based onthe particular quantum element 122 _(k) and/or signal path 313 _(k) towhich the pulse is to be transmitted (e.g., the resonant frequency ofthe quantum element, frame of reference, and/or mixer correction). Thedetermination of which quantum element and/or signal path to which aparticular pulser 302 _(l) is to send an outbound pulse at a particulartime may be predetermined in the quantum algorithm description or may bedetermined based on calculations performed by the pulser 302 _(l) and/orothers of the pulsers 302 ₀-302 _(L−1) during runtime. The controlcircuitry 502 may then use this information to configure the routingblock 506 such that the correct modification settings are routed to thecorrect one or more of the pulse modification circuits 508 ₀-508 _(L−1).

In an example implementation, the digital signal IF_(l) instructs thepulse operations manager 356 to update a frequency setting of themodification settings circuit 504 _(k) indicated by ops_slct_(l). In anexample implementation, the frequency setting is the matrix S_(k)(described above) and the signal IF_(l) carries new values indicatingthe new ω_(k) to be used in the elements of the matrix S_(k). The newvalues may, for example, be determined during a calibration routine(e.g., performed as an initial portion of the quantum algorithm) inwhich one or more of the pulsers 302 ₀-302 _(L−1) sends a series ofoutbound pulses CP, each at a different carrier frequency, and thenmeasures the corresponding inbound signals AI.

In an example implementation, the signal F_(l) instructs the pulseoperations manager 356 to update a frame setting of the modificationsettings circuit 504 _(k) indicated by ops_slct_(l). In an exampleimplementation, the frame setting is the matrix F_(k) (described above)and the signal F_(l) carries a rotation matrix F_(l) which multiplieswith F_(k) to rotate F_(k). This can be written as

${F_{k} = {{F_{1}F_{k}} = {{\begin{pmatrix}{\cos({\Delta\phi})} & {{- \sin}({\Delta\phi})} \\{\sin({\Delta\phi})} & {\cos({\Delta\phi})}\end{pmatrix}\begin{pmatrix}{\cos\left( \phi_{k} \right)} & {{- \sin}\left( \phi_{k} \right)} \\{\sin\left( \phi_{k} \right)} & {\cos\left( \phi_{k} \right)}\end{pmatrix}} = \begin{pmatrix}{\cos\left( {\phi_{k} + {\Delta t\beta}} \right)} & {{- \sin}\left( {\phi_{k} + {\Delta\phi}} \right)} \\{\sin\left( {\phi_{k} + {\Delta\phi}} \right)} & {\cos\left( {\phi_{k} + {\Delta\phi}} \right)}\end{pmatrix}}}},$where ϕ_(k) is the frame of reference before the rotation and Δϕ is theamount by which to rotate the frame of reference. The pulser 302 _(l)may determine Δϕ based on a predetermined algorithm or based oncalculations performed by the pulsers 302 _(l) and/or others of thepulsers 302 ₀-302 _(L−1) during runtime.

In an example implementation, the signal dmod_sclt_(l) informs the pulseoperations manager 356 from which of the modification settings circuits504 _(k) to retrieve values to be sent to pulser 302 _(l) as f_dmod_(l).The pulser 302 _(l) may determine dmod_slct_(l) based on the particularquantum element 122 _(k) and/or signal path 315 _(k) from which thepulse to be processed arrived. The determination of from which quantumelement and/or signal path a particular pulser 302 _(l) is to process aninbound pulse at a particular time may be predetermined in the quantumalgorithm description or may be determined based on calculationsperformed by the pulser 302 _(l) and/or others of the pulsers 302 ₀-302_(L−1) during runtime. The control circuitry 502 may then use thisinformation to configure the routing block 506 such that the correctmodification settings are routed to the correct one of the pulsers 302₀-302 _(L−1). For example, when pulse generation circuit 302 _(l) needsto demodulate a pulse signal AI_(l) from quantum element 122 _(k), itwill send a dmod_sclt_(l) signal instructing the pulse operation manager356 to rout the element SF_(k00)=cos(ω_(k)*time_stamp+ϕ_(k)) frommodification settings circuit 504 _(k) to pulser 302 _(l) (asf_dmod_(l)).

In the example implementation shown, the digital signals C₀-C_(K−1)provide information about signal-path-specific modification settings tobe used for each of the signal paths 313 ₀-313 _(K−1). For example, eachsignal C_(k) may comprise a matrix to be multiplied by a matrixrepresentation of a raw outbound pulse CP′_(l) such that the resultingoutput outbound pulse is pre-compensated for errors (e.g., resultingfrom imperfections in mixers, amplifiers, wiring, etc.) introduced asthe outbound pulse propagates along signal path 313 _(k). The result ofthe pre-compensation is that output outbound pulse CP_(l) will have theproper characteristics upon arriving at the quantum processor 218. Thesignals C₀-C_(K−1) may, for example, be calculated by the quantumcontroller 210 itself, by the programming subsystem 202, and/or byexternal calibration equipment and provided via I/O manager 368. Thecalculation of signals may be done as part of a calibration routinewhich may be performed before a quantum algorithm and/or may bedetermined/adapted in real-time as part of a quantum algorithm (e.g., tocompensate for temperature changes during the quantum algorithm).

FIG. 6A shows frequency generation circuitry of the quantum controllerof FIG. 3B. In the example implementation shown, the frequencygeneration circuitry is part of control circuitry 502 of pulseoperations manager circuitry 356. The frequency generation circuitrycomprises K coordinate rotation digital computer (CORDIC) circuits 602₀-602 _(K−1), phase generation circuitry 604, timestamp register 606,and S-Matrix generation circuitry 608.

Each CORDIC circuit 602 _(k) is operable to compute cosine and sine ofits input, θ_(k), thus generating two signals cos(θ_(k)) and sin(θ_(k)).

The phase generation circuitry 604 is operable to generate the CORDICinput parameters θ₀-θ_(k-1) based on: (1) the frequency setting signalsIF₀-IF_(L−1) from the pulsers 302 ₀-302 _(L−1); and (2) the contents,TS, of the timestamp register 606.

The timestamp register 606 comprises circuitry (e.g., a counterincremented on each cycle of the clock signal clk1) operable to trackthe number of cycles of clk1 since a reference point in time (e.g.,power up of the quantum controller 210, start of execution of set ofinstructions of a quantum algorithm by the quantum controller 210,etc.).

In the example shown, the phase generation circuitry 604 setsθ₀=2πf₀(TS)(dt_(clk1)), where f₀ is a frequency determined from thesignal IF₀, TS is the number of clock cycles counted from the referencepoint and dt_(clk1) is the duration of a single clock cycle of clk1.This leads to the CORDIC outputs being a pair of phase-quadraturereference signals, cos(2πf₀(TS)(dt_(clk1))) andsin(2πf₀(TS)(dt_(clk1))), as in the example shown, which are used togenerate the S₀ rotation matrix that rotates at a frequency f₀.

As shown in FIG. 6B, the signal IF_(l) may comprise an update componentand an f_(l) component. In an example implementation, when update, isasserted then the phase generation circuitry updates one of more off₀-f_(K−1) to be the value of f_(l).

The S-matrix generation circuitry 608 is operable to build the matricesS₀-S_(K−1) from the outputs of the CORDIC circuits 602 ₀-602 _(K−1). Inan example implementation, the S-matrix generation circuit 606 isoperable to synchronize changes to the S matrices such that any matrixupdate occurs on a desired cycle of clock clk1 (which may be determinedby the control information IF₀-IF_(L−1)).

With K CORDIC circuits 602 _(k), the frequency generation circuitry isoperable to concurrently generate K S-matrices. In instances that morethan K frequencies are needed over the course of a set of instructions,the phase generation circuit 604 is operable to change the inputparameter θ_(k) of one or more of the CORDIC circuits 602 ₀-602 _(K−1)to stop generating one frequency and start generating the K+1thfrequency. In some instances, it may be necessary for the new frequencyto start at a phase θ that would have been the phase if the newfrequency was being generated from the initial reference time (e.g.,because the new frequency would be used to address a quantum elementthat has a resonance at the new frequency and that was coherent sincethe reference point). In some other instances, it might be necessary tostart the new frequency from the phase that the old frequency ended in.The phase generation circuit 604 and timestamp register 606 enable bothof these possibilities.

FIG. 7 shows an example implementation of the digital manager of FIG.3B. Shown in FIG. 7 are the digital manager 376, controlled circuits 710₀-710 _(J−1), and input manager 372.

The example implementation of the digital manager 376 comprises inputrouting circuit 702, configuration circuit 704, output routing circuit706, processing paths 708 ₀-708 _(Z−1) (where Z is an integer), androuting control circuit 712.

The configuration circuit 704 is operable to store configurationsettings and use those settings to configure the processing paths 708₀-708 _(Z−1) and/or the routing control circuit 712. The settings may,for example, be loaded via the signal DM_config as part of the quantumalgorithm description provided by quantum programming subsystem 202. Thesettings may comprise, for example, one or more of: a bitmap on whichmay be based a determination of which of signals D₀-D_(L−1) to route towhich of signals P′₀-P′_(Z−1) for one or more instructions of a quantumalgorithm; a bitmap on which may be based a determination of whichprocessing path outputs P₀-P_(Z−1) to route to which ofDigOut₀-DigOut_(J+M−1) for one or more instructions of a quantumalgorithm; and one or more bit patterns which processing paths 708 ₀-708_(Z−1) may convolve with one or more of the signals P′₀-P′_(Z−1) for oneor more instructions of a quantum algorithm.

The input routing circuit 702 is operable to route each of the digitalsignals D₀-D_(L−1) to one or more of the processing paths 708 ₀-708_(Z−1). At any given time (e.g., for any particular instruction of everypulser 302 _(l) of pulsers 302 ₀-302 _(L)), the input routing circuit702 may determine to which of the processing paths 708 ₀-708 _(Z−1) torout the signal Di of signals D₀-D_(Ll) based on the signal fanin_(l) ofsignals fanin₀-fanin_(L−1). That is, for a particular instruction, thedigital signal Di may be routed to any one or more of paths 708 ₀-708_(Z−1) based on the value of fanin_(l) for that instruction. Forexample, fanin_(l) may be a Z-bit signal and a state of each bit offanin_(l) during a particular instruction may indicate whether D_(l) isto be routed to a corresponding one of the Z processing paths 708 ₀-708_(Z−1) during that instruction. An example implementation of the inputrouting circuit 702 is described below with reference to FIG. 8 .

The output routing circuit 706 is operable to route each of the digitalsignals P₀-P_(Z−1) to one or more of DigOut₀-DigOut_(J+M−1) (In theexample shown DigOut₀-DigOut_(J+M−1) connect to stream₀-stream_(M-1),respectively, and DigOut_(M)-DigOut_(J+M−1) connect toDigCtrl0-DigCtrlJ−1, respectively). At any given time (e.g., for anyparticular instruction of every pulser 302 _(l) of pulsers 302 ₀-302_(L)), the output routing circuit 706 may determine to which ofDigOut₀-DigOut_(J+M−1) to rout the signal P_(l) of the signalsP₀-P_(L−1) based on the signal fanout_(l) of signalsfanout₀-fanout_(Z−1). That is, for a particular instruction, the digitalsignal P_(z) (z an integer between 0 and Z) may be routed to any one ormore of DigOut₀-DigOut_(J+M−1) based on the value of fanout_(z) for thatinstruction. For example, values of fanout_(z) may be (J+M−1) bits and astate of each bit of fanout_(z) during a particular instruction mayindicate whether P_(z) is to be routed to a corresponding one of theJ+M−1 signals DigOut during that instruction. An example implementationof the output routing circuit 704 is described below with reference toFIG. 8 .

Each of the processing path circuits 708 ₀-708 _(Z−1) is operable tomanipulate a respective one of signals P′₀-P′_(Z−1) to generate acorresponding manipulated signal P₀-P_(Z−1). The manipulation maycomprise, for example, introducing a delay to the signal such that theresulting one or more of DigOut₀-DigOut_(J+M−1) reach(es) its/theirdestination (a controlled circuit 710 and/or input manager 372) at theproper time with respect to the time of arrival of a correspondingquantum control pulse at the corresponding destination.

Each of the controlled circuits 710 ₀-710 _(J−1) and input manager 372is a circuit which, at least some of the time, needs to operatesynchronously with quantum control pulses generated by one or more ofpulsers 302 ₀-302 _(L−1) (possibly a reflection/return pulse from aquantum processor in the case of input manager 372). Accordingly, eachof the control circuits 710 ₀-710 _(J−1) receives a respective one ofcontrol signals DigOut₀-DigCtrl_(J−1) that is synchronized with arespective quantum control pulse. Similarly, input manager 372 receivesa plurality of the DigOut signals (one for each stream input).

The routing controller 712 comprises circuitry operable to generatesignals fanin₀-fanin_(L−1) and fanout₀-fanout_(Z−1) based onD_path₀-D_path_(L−1), D_port₀-D_port_(L−1), and/or information stored inconfiguration circuit 704.

FIG. 8 shows an example implementation of the digital manager of FIG.3B. The example input routing circuit 502 comprises routing circuits 802₀-802 _(L−1) and combining circuits 804 ₀-804 _(L−1). The example outputrouting circuitry 506 comprises circuits routing circuits 808 ₀-808_(Z−1) and combining circuits 810 ₀-810 _(J−1). The example processingpath circuits are convolution circuits 806 ₀-806 _(Z−1).

Each of the routing circuits 802 ₀-802 _(L) is operable to route arespective one of signals D₀-D_(L−1) to one or more of the combiningcircuits 804 ₀-804 _(Z−1). To which of combining circuit(s) 804 ₀-804_(Z−1) the signal D_(l) is routed is determined based on the signalfanin_(l). In an example implementation, each signal fanin_(l) is aZ-bits signal and, for a pulser_(l) instruction, the value of bit z ofthe signal fanin_(l) determines whether the signal Di is to be routed tocombining circuit 804 _(z) for that instruction. The value of fanin_(l)may be updated on a per-instruction basis.

Each of combining circuits 804 ₀-804 _(L−1) is operable to combine up toL of the signals D0-DL−1 to generate a corresponding one of signalsP₀-P_(Z−1). In an example implementation, the combining comprises OR-ingtogether the values of the up to L signals.

Each of the routing circuits 808 ₀-808 _(Z−1) is operable to route arespective one of signals P′₀-P′_(Z−1) to one or more of the combiningcircuits 810 ₀-810 _(L−1). To which of combining circuit(s) 810 ₀-810_(J−1) the signal P′_(z) is routed is determined based on the signalfanout_(z). In an example implementation, each signal fanout_(z) is a(J+M−1)-bit signal and the value of bit j+m−1 of the signal fanout_(z)determines whether the signal P′_(z) is to be routed to combiningcircuit 804 _(j+m−1). In an example implementation the value offanout_(z) is preconfigured before the runtime of the quantum algorithm,however, in another implementation it may be updated dynamically (e.g.,on a per-instruction basis).

Each combining circuit of combining circuits 810 ₀-810 _(J−1) isoperable to combine up to Z of the signals P′₀-P′_(Z−1) (received viainputs 803 ₀ to 803 _(Z−1)) to generate a corresponding one of signalsDigOut₀-DigOut_(J+M−1). In an example implementation, the combiningcomprises OR-ing together the values of the up to Z signals.

Each convolution circuit 806 _(z) is operable to convolve signal P_(z)with pattern_(z) to generate signal P′_(z). In an exampleimplementation, pattern_(z) is preconfigured before runtime of thequantum algorithm, however, in another implementation it may be updateddynamically. pattern_(z) may be determined based on: the destination(s)of signal P_(z) (e.g., to which of controlled circuits 510 and/or inputof input manager 352 P_(z) is intended); characteristics of thecorresponding quantum control pulse (e.g., any one or more of itsfrequency, phase, amplitude, and/or duration); and/or process,temperature, and/or voltage variations.

FIG. 9 illustrates configuration and control of the quantum controllervia the quantum programming subsystem. In FIG. 9 , the quantumcontroller 210 comprises one or more instances of various circuits (suchas the pulser, input manager, output manager, digital manager, pulseoperations manager, and analog front end circuits described above).Connected to the inputs and outputs of the quantum controller 210 may bea plurality of external devices (e.g., oscilloscopes, waveformgenerators, spectrum analyzers, mixers, amplifiers, etc.) and aplurality of quantum elements. As described in further detail below,these physical circuits can be allocated and deallocated independentlyof one another such that the physical resources of the quantumcontroller 210, and the quantum elements and external devices connectedto the quantum controller 210 via the analog and digital inputs andoutputs, can be organized into one or more “quantum machines.”

Also shown in FIG. 9 are a compiler 906 and quantum machines manager 908of the quantum programming subsystem 202.

The compiler 906 comprises circuitry operable to generate a machine codequantum algorithm description based on: (1) a specification 902; (2) apulse generation program 904; and (3) a resources management datastructure from the quantum machines manager 908.

The specification 902 identifies resources of a quantum machine some ofwhich are mapped to physical circuits during an instantiation of aquantum machines (e.g. input and output ports of the quantum controller2|0), and some of which the compiler attaches to physical circuits ofthe quantum controller 210 during compilation of a Pulse generationProgram 904. The compiler 906 may allocate resources for executing theprogram 904 based on the specification 902, the program 904, and/or theavailable resources indicated by the quantum machines manager 908. As anexample, assume a scenario in which there are five quantum elements inthe specification 902 and the program 904 uses only two of the quantumelements; the number of the pulsers 302 ₀-302 _(L) allocated may dependon the available resources and the specifics of the program 904. In onecase the compiler 906 may allocate a first number (e.g., two) of thepulsers 302 ₀-302 _(L) for interfacing with the two quantum elements andin another case the compiler may allocate a second number (e.g., four)for sending pulses to the two quantum elements. Examples of resourcedefinitions which may be present in specification 902 are describedbelow with reference to FIGS. 10A-C. In an example implementation,Python is used as a “host” language for the specification and thespecification is a Python dictionary. In this example implementation thePython syntax/constructs can thus be leveraged to create thespecification (Python variables, functions, etc.).

The pulse generation program 904 comprises statements that define asequence of operations to be performed by the quantum machine defined inthe specification 902. Such operations typically include the generationof one or more analog pulses to be sent to a controlled element, such asa quantum element. Such operations typically include measuring one ormore return pulses from an element. The pulse generation program is alsoreferred to herein as a QUA program. Functions, syntax, etc. of the QUAprogramming language are described below. In an example implementation,Python is used as a “host” language for the QUA program. This allowsleveraging Python syntax/constructs (Python variables, functions, etc.)to generate the QUA program, but it is still a QUA—not Python—program tobe compiled by the compiler 906 to generate QOP machine code, and to beexecuted on the quantum controller/s 210.

In an example implementation, a QUA program defines the sequence ofstatements for: (1) Generating, shaping and sending pulses to thequantum device; (2) Measuring of pulses returning from the quantumdevice; (3) Performing real-time classical calculations on the measureddata and storing results in classical variables; (4) Performingreal-time classical calculations on classical variables; (5) Controllingthe flow of the program, including branching statements; and (6)Streaming of data from the quantum controller 210 to the quantumprograming system 202 and processing and saving it in the quantumprograming system 202.

In addition to the specification of which pulses are played, a QUAprogram can also specify when they should be played through bothexplicit and implicit statements and dependency constructs. Thus, a QUAprogram can define exactly the timing in which pulses are played, downto the single sample level and single clock cycles of the quantumcontroller 210.

In an example implementation, the pulses syntax defines an implicitpulse dependency, which determines the order of pulse execution. Thedependency can be summarized as follows: (1) Each pulse is playedimmediately, unless dependent on a previous pulse yet to be played; (2)Pulses applied to the same quantum element are dependent on each otheraccording to the order in which they are written in the program Inanother implementation, timing and ordering or pulses may be set forthexplicitly in the QUA program.

Example QUA programming constructs are described below in Table 1.

TABLE 1 QUA programming constructs play(pulse * amp(g₀₀, g₀₁, g₁₀, g₁₁),qe, duration=None, condition=None, break_condition=None ) Play a pulseto an element. The pulse will be modified according to the properties ofthe element defined in the specification, and then played to the analogoutput(s) defined in the specification. Parameters: pulse - name of thepulse, as defined in the quantum machine specification. qe - name of thequantum element, as defined in the quantum machine specification.duration - duration of the pulse (″=None″ means default is no explicitduration) g_(ij) - an expression; amp( ) - matrix definition;condition - if present, the pulse will be played with the conditionevaluates to true (″=None″ means default is no condition);break_condition - if present, the pulser will be stopped when thecondition evaluates to true (″=None″ means default is nobreak_condition); It is possible to scale the pulse′s amplitudedynamically by using the following syntax: play(′pulse_name′ * amp(v),′element′), where amp(v) = mat(v, 0, 0, v) where v is a variable.Moreover, if the pulse is intended for an element that receives a pulsepair and thus is defined with two waveforms, the two waveforms,described as a column vector, can be multiplied by a matrix:play(′pulse_name′ * amp([v_00, v_01, v_10, v_11]), ′element′), wherev_ij, i,j={0,1}, are variables. Example: >>> with program( ) asprog: >>> v1 = declare(fixed) >>> assign(v1, 0.3) >>> play(′pulse1′,′qe1′) >>> play(′pulse1′ * amp(0.5), ′qe1′) >>> play(′pulse1′ * amp(v1),′qe1′) >>> play(′pulse1′ * amp([0.9, v1, −v1, 0.9]), ′qe_iq_pair′)wait(duration, *qes) Wait for the given duration on all providedelements. During the wait command the quantum controller 210 will output0.0 to the elements.  Parameters: duration (int | QUA variable of typeint) - time to wait (e.g., in multiples of 4nsec with Range: [4, 2²⁴] insteps of 1). *qes (str | sequence of str) - elements to wait on (theAsterix denotes there can be 0 or more) measure(pulse, qe, Rvar,*outputs) The measure statement allows operating on a quantum element(which has outputs), by sending a pulse to it, after some time acquiringthe returning signal and processing it in various ways An element forwhich a measurement is applied must have outputs defined in the quatummachine specification. A measurement may comprise:  • playing a pulse tothe element (identical to a play statement)  • waiting for a duration oftime defined as the time_of_flight in the definition of the element, andthen sampling the returning pulse. The analog input to be sampled isdefined in the definition of the element.  • processing the returnedsamples using the listed process(es) (if any). The processing could be,for example, demodulation and integration with specified integrationweights, which produces a scalar, accumulated demodulation andintegration that produces a vector, a sequence of demodulation andintegrations that produces a vector, FIR filter, neural network.Parameters  pulse - name of the pulse, as defined in the quantum machinespecification. Pulse must have  a measurement operation.  qe - name ofthe element, as defined in the quantum machine specification. Theelement must  have outputs.  Rvar - a result variable reference, astring, or ‘None’. If Rvar is a result variable reference, the  raw ADCdata will be sent to the quantum programing subsystem 202 and processedthere  according to the result processing section of the QUA program. IfRvar is a string, the raw ADC  data will be sent to the quantumprogramming subsystem 202 and saved as it is with the default  minimalprocessing. If Rvar is set to None, raw results will not be sent toquantum programming  subsystem 202 and will not be saved. In oneimplementation, the raw results will be saved as long  as the digitalpulse that is played with pulse is high.  outputs - a tuple with theform (processing identifier, params, variable name), where: processingidentifier  defined in the top-level specification and/or in reservedwords of the QUA language  and referred to in the pulse definition. Aprocessing identifier may, for example, refer  to a set of integrationweights, or neural network parameters, or the like. Params  parameterspassed to the processing reference variable name  the name of a QUAvariable to which the processing result is assigned.  zero or moreoutput tuples may be defined. Example: >>> with program( ) asprog: >>> I = declare(fixed) >>> Q = declare(fixed) >>> >>> # measure byplaying ′meas_pulse1′ to QE ′rr1′, do not save raw results. >>> #demodulate and integrate using ′cos_weights′ and store result in I, andalso >>> # demodulate and integrate using ′sin_weights′ and store resultin Q >>> measure(′meas_pulse1′, ′rr1′, None, (‘int’, ′cos_weights′, I),(‘int’ ′sin_weights′, Q)) >>> >>> # measure by playing ′meas_pulse2′ toQE ′rr1′, save raw results to tag ′samples′. >>> # demodulate andintegrate data from ′out1′ port of ′rr1′ using ′optimized_weights′ asintegration weights >>> # store result in I >>> measure(′meas_pulse2′,′rr1′, ′samples′, (‘int’, ′optimized_weights′, ′out1′, I)) align(*qes)Align several quantum elements together. All of the quantum elementsreferenced in *qes will wait for all the others to finish theircurrently running statement. Parameters • *qes (str | sequence of str) -a single quantum element, or list of quantum elements pause( ) Pause theexecution of the job until QmJob.resume( ) is called. The quantummachines freezes on its current output state. declare(t) Declare a QUAvariable to be used in subsequent expressions and assignments.Declaration is performed by declaring a python variable with the returnvalue of this function. Parameters • t - The type of QUA variable.Possible values: int, fixed, bool, where:  int  a signed 32-bit number fixed  a signed 4.28 fixed point number  bool  either True or FalseReturns The variable Example: >>> a = declare(fixed) >>> play(′pulse′ *amp(a), ′qe′) assign(var,_exp) Set the value of a given QUA variable.Parameters • var (QUA variable) - The variable to set (defined by thedeclare function) • _exp (QUA expression) - An expression to set thevariable to Example: >>> with program( ) as prog: >>> v1 =declare(fixed) >>> assign(v1, 1.3) >>> play(′pulse1′ * amp(v1), ′qe1′)save(var, tag) Save a QUA variable with a given tag. The tag will appearlater as a field in the saved results object returned byQmJob.get_results( ). The type of the variable determines the pythontype, according to the following rule:  •  int −> int  •  fixed −> float •  bool −> bool Parameters • var (QUA variable) - A QUA variable tosave • tag (str) - A name to save the value under update_frequency(qe,new_frequency) Dynamically update the frequency of the NCO associatedwith a given quantum element. This changes the frequency from the valuedefined in the quantum machine specification. Parameters • qe (str) -The quantum element associated with the NCO whose frequency will bechanged • new_frequency (int) - The new frequency value to set in unitsof Hz. Range: (0 to 5000000) in steps of 1. Example: >>> with program( )as prog: >>> update_frequency(″q1″, 4000000) z_rotation(angle, *qes)Shift the phase of the NCO associated with a quantum element by thegiven angle. This is typically used for virtual z-rotations. Equivalentto z_rot( ) Parameters • angle (float) - The angle to add to the currentphase (in radians) • *qes (str | sequence of str) - A quantum element,or sequence of quantum elements, associated with the NCO whose phasewill be shifted z_rot(angle, *qes) Shift the phase of the NCO associatedwith a quantum element by the given angle. This is typically used forvirtual z-rotations. Equivalent to z_rotation( ) Parameters • angle(float) - The angle to add to the current phase (in radians) • *qes (str| sequence of str) - A quantum element, or sequence of quantum elements,associated with the NCO whose phase will be shifted set_frame(qes,angle) Set the phase of the frame matrix associated with a quantumelement to the given angle. reset_phase(qes, angle) Set the total phaseof the frequency modulation of a quantum element to zero (both thefrequency modulation matrix and the frame matrix). infinite_loop_( )Infinite loop flow control statement in QUA. To be used with a contextmanager. Optimized for zero latency between iterations, provided that nomore than a single quantum element appears in the loop. Note In casemultiple quantum elements need to be used in an infinite loop, it ispossible to add several loops in parallel (see example). Example: >>>with infinite_loop_( ): >>> play(′pulse1′, ′qe1′) >>> withinfinite_loop_( ): >>> play(′pulse2′, ′qe2′) for(var=None, init=None,cond=None, update=None) For loop flow control statement in QUA. To beused with a context manager. Parameters • var (QUA variable) - QUAvariable used as iteration variable • init (QUA expression) - anexpression which sets the initial value of the iteration variable • cond(QUA expression) - an expression which evaluates to a boolean variable,determines if to continue to next loop iteration • update (QUAexpression) - an expression to add to var with each loop iterationExample: >>> x = declare(fixed) >>> with for(var=x, init=0, cond=x<=1,update=x+0.1): >>> play(′pulse′, ′qe′) if(condition) If flow controlstatement in QUA. To be used with a context manager. The QUA code blockfollowing the statement will be executed only if condition evaluates totrue. Parameters • condition - A boolean expression to evaluateExample: >>> x=declare(int) >>> with if_(x>0): >>> play(′pulse′, ′qe′)else Else flow control statement in QUA. To be used with a contextmanager. Must appear after an if( ) statement. The QUA code blockfollowing the statement will be executed only if expression in precedingif( ) statement evaluates to false. Example: >>> x=declare(int) >>> withif(x>0): >>> play(′pulse′, ′qe′) >>> with else(): >>> play(′other_pulse′, ′qe′)

The Play statement in QUA instructs the quantum controller 210 to sendthe indicated pulse to the indicated element. The quantum controller 210will modify or manipulate the pulse according to the element'sproperties defined in the quantum machine specification (i.e., thecompiler will generate the required pulse modification settings whichwill then be stored to the appropriate one or more of pulse modificationsettings circuit(s) 504 ₀-504 _(K−1), so the user is relieved of theburden of having to specify the modifications/manipulations in eachindividual Play statement.

If the element has a single input, the pulse sent to it may be definedwith a single waveform. For example:

‘elements’: {  ‘qubit’: {   ‘SingleInput’: {   ‘port’: (‘con1’, 1),   },  ‘intermediate_frequency’: 70e6,   ‘operations’: {   ‘pulse1’: ‘pulse1’  },  }, } ‘pulses’: {  ‘gauss_pulse_in’: {   ‘operation’: ‘control’,  ‘length’: 12,   ‘waveforms’: {   ‘single’: ‘wf1’,   },  }  },‘waveforms’: {  ‘wf1’: {   ‘type’: ‘arbitrary’,    ‘samples’:[0.49,0.47, 0.44, 0.41, 0.37, 0.32, 0.32, 0.37,    0.41, 0.44, 0.47, 0.49]  },}

Denoting the samples of the waveform as s_(i), the play statementinstructs the quantum controller 210 to modulate the waveform sampleswith the intermediate frequency of the element:{tilde over (s)} _(i) =s _(i) cos(ω_(IF) t+ϕ _(F))ω_(IF), is the intermediate frequency defined in the quantum machinespecification of the element and ϕ_(F) is the frame phase, initially setto zero (see z_rot statement specifications for information on ϕ_(F)).The quantum controller 210 then plays s_(i) to the analog output portdefined in the definition of the element (in the above example, port 1).

If the element has two mixed inputs (i.e. two output ports of thequantum controller 210 are connected to the element via an IQ mixer), inaddition to the intermediate frequency, a mixer and a lo_frequency maybe defined in the quantum machine specification. For example:

‘elements’: {  ‘qubit’: {   ‘mixedInputs’: {   ‘I’: (‘con1’, 1),   ‘Q’:(‘con1’, 2),   ‘mixer’: ‘mixer1’,   ‘lo_frequency’: 5.1e9,   },  ‘intermediate_frequency’: 70e6,   ‘operations’: {   ‘pulse1’: ‘pulse1’  },  }, },

A pulse that is sent to such element may be defined with two waveforms.For example:

‘pulses’: {  ‘pulse1’: {   ‘operation’: ‘control’,   ‘length’: 12,  ‘waveforms’: {   ‘I’: ‘wf_I’,   ‘Q’: ‘wf_Q’,   },  },  }, ‘waveforms’:{  ‘wf_I’: {   ‘type’: ‘arbitrary’,   ‘samples’:[0.49, 0.47, 0.44, 0.41,0.37, 0.32, 0.32, 0.37, 0.41,   0.44, 0.47, 0.49]  },  ‘wf_Q’: {  ‘type’: ‘arbitrary’,   ‘samples’: [0.02, 0.03, 0.03, 0.04, 0.05, 0.00,0.05, 0.04,    0.03, 0.03, 0.02, 0.02]  }, }

In addition, a mixer can be defined with a mixer correction matrix thatcorresponds to the intermediate_frequency and the lo_frequency. Forexample:

‘mixers’: {  ‘mixer1’: [   {    ‘intermediate_frequency’: 70e6,   ‘lo_frequency’: 5.1e9,    ‘correction’: [0.9, 0.003, 0.0, 1.05]   }],

Denoting the samples of the waveforms by I_(i) and Q_(i), the playstatement instructs the quantum controller 210 to modulate the waveformsamples with the intermediate frequency of the element and to apply themixer correction matrix in the following way:

$\begin{pmatrix}\overset{˜}{I_{\iota}} \\\overset{˜}{Q_{\iota}}\end{pmatrix} = {\begin{pmatrix}C_{00} & C_{01} \\C_{10} & C_{11}\end{pmatrix}\begin{pmatrix}{\cos\left( {{\omega_{IF}t} + \phi_{F}} \right)} & {{- \sin}\left( {{\omega_{IF}t} + \phi_{F}} \right)} \\{\sin\left( {{\omega_{IF}t} + \phi_{F}} \right)} & {\cos\left( {{\omega_{IF}t} + \phi_{F}} \right)}\end{pmatrix}\begin{pmatrix}I_{i} \\Q_{i}\end{pmatrix}}$ω_(IF) ω_(IF), is the intermediate and the C_(ij)'s are the matrixelements of the correction matrix defined in the mixer for the relevantintermediate_frequency and lo_frequency. As mentioned above, ϕ_(F) isthe frame phase, initially set to zero (see z_rot statementspecifications for information on ϕ_(F)). The quantum controller 210then plays I_(i) and Q_(i) to the analog output ports defined in thedefinition of the element (in the above example, port 1 and port 2,respectively).

An element could have digital inputs as well as analog inputs. Eachdigital input of an element may be defined with three properties: port,delay, and buffer. For example:

‘elements’: {  ‘qubit’: {   ‘mixedInputs’: {   ‘I’: (‘con1’, 1),   ‘Q’:(‘con1’, 2),   ‘mixer’: ‘mixer1’,   ‘lo_frequency’: 5.1e9,   },  ‘intermediate_frequency’: 70e6,   ‘digital_inputs’:  ‘digital_input1’:    ‘port’: (cont1, 1)    ‘delay’: 144    ‘buffer’: 8  ‘digital_input2’:    ‘port’: (cont1, 2)    ‘delay’: 88    ‘buffer’: 20  ‘operations’: {   ‘pulse1’: ‘pulse1’   },  }, },

For a simple example, a pulse that is played to such quantum elementcould include a single digital marker which points to a single digitalwaveform. For example:

‘pulses’: {  ‘pulse1’: {   ‘operation’: ‘control’,   ‘length’: 40,  ‘waveforms’: {   ‘I’: ‘wf_I’,   ‘Q’: ‘wf_Q’,   },   ‘digital_marker’:‘digital_waveform_high’  },  }, ‘digital_waveforms’: { ‘digital_waveform_high’: {   ‘samples’: [(1, 0)]  }, }

The coding of the digital waveform may be a list of the form: [(value,length), (value, length), . . . , (value, length)], where each value iseither 0 or 1 indicating the digital value to be played (digital high orlow). Each length may be an integer (e.g., divisible by 4 in one exampleimplementation) indicating for how many nanoseconds the value should beplayed. A length 0 indicates that the corresponding value is to beplayed for the remaining duration of the pulse. In the example above,the digital waveform is a digital high.

When such pulse is played to the element, via the play or themeasurement command, the digital waveform may be sent to all the digitalinputs of the element. For each digital input, however, the quantumcontroller 210 may: (1) Delay the digital waveform by the delay that isdefined in the definition of the digital input (e.g., given in ns); (2)Convolve the digital waveform with a digital pattern that is high for aduration which is, for example, twice the buffer that is defined in thedefinition of the digital input (e.g., given in ns in a “buffer”); and(3) Play the digital waveform to the digital output of the quantumcontroller 210 that is indicated in the quantum machine specification tobe connected to the digital input. In other implementations, the digitalpattern with which the digital waveform to be convolved may be morecomplex than a simple high value. In one such example, the “buffer”object may comprise “duration” and “pattern” properties.

In the example above a play(pulse1, qubit) command would play: (1) Adigital waveform to digital output 1, which starts 144 ns after theanalog waveforms and which is high for 56 ns (the length of the pulseplus 2×8 ns); and (2) A digital waveform to digital output 2, whichstarts 88 ns after the analog waveforms and which is high for 80 ns (thelength of the pulse plus 2×20 ns).

A measurement can be done for an element that has outputs defined in thequantum machine specification. For example:

‘elements’: {  ‘resonator’: {   ‘mixedInputs’: {   ‘I’: (‘con1’, 3),  ‘Q’: (‘con1’, 4),   ‘mixer’: ‘mixer1’,   ‘lo_frequency’: 7.3e9,   },  ‘intermediate_frequency’: 50e6,   ‘outputs’: {   ‘out1’: : (‘con1’,1),   },   ‘time_of_flight’: 196,   ‘smearing’: 20,  }, },

As seen in the above example, when a quantum element has outputs, twoadditional properties may be defined: time_of_flight and smearing. Thepulse used in a measurement statement may also be defined as ameasurement pulse and may have integration_weights defined. For example:

‘pulses’: {  ‘pulse1’: {   ‘operation’: ‘measurement’,   ‘length’: 400,  ‘waveforms’: {   ‘I’: ‘meas_wf_I’,   ‘Q’: ‘meas_wf_Q’,   },  ‘integration_weights’: {   ‘integ1’: ‘integW1’,   ‘integ2’: ‘integW2’,  } ‘integration_weights’: {  ‘integW1’: {   ‘cosine’: [0.0, 0.5, 1.0,1.0, ..., 1.0, 0.5, 0.0]   ‘sine’: [0.0, 0.0, ..., 0.0]  },  ‘integW2’:{   ‘cosine’: [0.0, 0.0, ..., 0.0]   ‘sine’: [0.0, 0.5, 1.0, 1.0, ...,1.0, 0.5, 0.0]  }, }

A measurement statement, such as the one shown above, instructs thequantum controller 210 to: (1) Send the indicated pulse to the indicatedelement, manipulating the waveforms in the same manner that is describedin the play statement section above; (2) After a time periodtime_of_flight (e.g., given in ns), samples the returning pulse at thequantum controller 210 input port/s that is/are connected to theoutput/s of the element. It saves the sampled data under stream_name(unless stream_name=None, in which case the sampled data will not besaved). The sampling time window will be of a duration that is theduration of the pulse plus twice the smearing (e.g., given in ns). Thisaccounts for the returning pulse that is longer than the sent pulse dueto the response of the quantum device, as well as for the cables andother elements in the pulse's path; and (3) Demodulate the sampled datawith a frequency intermediate_frequency, defined in the definition ofthe element, perform weighted integration on the demodulated data withintegration_weights that are defined in the quantum machinespecification, and put the result in the indicated variable. The quantumcontroller 210 can perform multiple (e.g., 10 or more) demodulations andintegrations at any given point in time, which may or may not be a partof the same measurement statement. The precise mathematical operation onthe sampled data is:

${variable} = {\sum\limits_{i}{s_{i}\left\lbrack {{w_{c}^{i}\cos\left( {{\omega_{IF}t_{i}} + \phi_{F}} \right)} + {w_{s}^{i}\sin\left( {{\omega_{IF}t_{i}} + \phi_{F}} \right)}} \right\rbrack}}$where s_(i) is the sampled data, ω_(IF) is the intermediate_frequency,ϕ_(F) is the frame phase discussed in the z_rot statement below, andw_(c) ^(i) and w_(s) ^(i) are the cosine and sine integration_weights.In an example implementation, the integration_weights are defined in atime resolution of 4 ns, while the sampling is done with time resolutionof 1 ns (1 GSa/Sec sampling rate):w _(c/s) ^(4i) +w _(c/s) ^(4i+1) +w _(c/s) ^(4i+2) +w _(c/s) ^(4i+3)

Compilation may include allocating specific resources of the quantumcontroller 210 to that quantum machine and then generating machine codethat, when executed by quantum controller 210, will use those allocatedresources.

The quantum machines manager 908 comprises circuitry operable todetermine resources present in the quantum controller 210 and theavailability of those resources at any given time. To determine theresources, the quantum machines manager 908 may be operable to read oneor more configuration registers of the quantum controller 210, inspect anetlist of one or more circuits of the quantum controller 210, and/orparse hardware description language (HDL) source code used to definecircuits of the quantum controller 210 and/or other files used todescribe various configurations of the hardware and software components.Once the resources are determined, the quantum machines manager 908 maykeep track of which resources are in use and which are available basedon which quantum machines are “open” (i.e., in a state where someresources are reserved for that machine regardless of which, if any,quantum algorithm description that quantum machine is executing at thattime), and/or which quantum algorithm descriptions are loaded intoand/or being executed by the quantum controller 210 at that time. Forexample, referring briefly to FIG. 13A, during a time period where twoquantum machines are open, each executing one of a first two quantumalgorithms descriptions (QAD) (“Program 1” and “Program 2”), the systemmay be configured as shown in FIG. 13A and a data structure managed bythe quantum machines manager 908 may reflect the situation as shown inTable 2.

TABLE 2 Example data structure maintained by quantum machines managerResource Status Pulser 1 Allocated to program 2 Pulser 2 Allocated toprogram 2 Pulser 3 Allocated to program 1 Pulser 4 Available Port 1Allocated to QM2 Port 2 Available Port 3 Allocated to QM2 Port 4Allocated to QM1 Port 5 Allocated to QM1 Port 6 Allocated to QM2 Port 7Allocated to QM1 Port 8 Allocated to QM1During another time period where a single quantum machine is open andexecuting a third algorithm description (“Program 3”), the system may beconfigured as shown in FIG. 13B. The data structure managed by thequantum machines manager 908 may reflect the situation as shown in Table3.

TABLE 3 Example data structure maintained by quantum machines managerResource Status Pulser 1 Allocated to program 3 Pulser 2 Allocated toprogram 3 Pulser 3 Allocated to program 3 Pulser 4 Allocated to program3 Port 1 Allocated to QM3 Port 2 Allocated to QM3 Port 3 Allocated toQM3 Port 4 Allocated to QM3 Port 5 Allocated to QM3 Port 6 Allocated toQM3 Port 7 Allocated to QM3 Port 8 Allocated to QM3

Table 4 below shows an example schema which uses Python as a hostlanguage the quantum machine specification is one or more Pythondictionaries.

TABLE 4 Example quantum machine specification schema version integer<int32> schema version. controllers object A collection of controllers.Each controller represents a control and computation resource on thequantum controller 210 hardware. property name* object (controller)specification of a single quantum control module. Here we define itsstatic properties. analog_outputs object a collection of analog outputports and the properties associated with them property name* objectspecification of the properties of a physical analog output port of thequantum control module. offset number DC offset to output, range: (−0.5,0.5). Will be applied only when program runs. digital_outputs objectproperty name* object (quantum control module digital port)specification of the properties of a physical digital output port of thequantum control module. offset number analog object a collection ofanalog output ports and the properties associated with them. Propertyname* object (quantum control module analog output port) specificationof the properties of a physical analog output port of the quantumcontrol module. offset number DC offset to output, range: (−0.5, 0.5).Will be applied only when program runs. type string Default: “opx1”analog_inputs object Property name* object (quantum control moduleanalog input port) specification of the properties of a physical digitalinput port of the quantum control module. offset number elements objectA collection of quantum elements and/or external devices. Each quantumelement represents and describes a controlled entity which is connectedto the ports (analog input, analog output and digital outputs) of thequantum control module. property_name* object (quantum element (QE))specification of a single element. Here we define to which port of thequantum control module the element is connected, what is the RFfrequency of the pulses sent and/or received from this element frequencyinteger <int32> resonance frequency [Hz]. Actual carrier frequencyoutput by the quantum control module to the input of this QE isfrequency-lo_frequency. mixInputs object (mixer input) specification ofthe input of a QE which is driven by an IQ mixer I string (tuple) of theform ((string) controller name, (int) controller output/input port) Qstring (tuple) of the form ((string) controller name, (int) controlleroutput/input port) mixer string the mixer used to drive the input of theQE, taken from the names in mixers entry in the main quantum machinespecification lo_frequency integer <int32> the frequency of the localoscillator which drives the mixer outputs collection of up to two outputports of QE. Keys: “outl” and “out2”. property_name* string (tuple) ofthe form ((string) controller name, (int) controller output/input port)intermediate_frequency integer <int32> intermediate frequency [Hz]. Theactual frequency to be output by the quantum control module to the inputof this element measurement_qe String A reference to an element that hasoutputs (and thus can be measured using the measurement command). Thiscan be specified for any element that does not have outputs so thatwhenever a measurement command is used to measure this elements, theactual measurement will be of the referenced element. smearing integer<int32> padding time, in nsec, to add to both the start and end of theraw data streaming window during a measure command. time_of_flightinteger <int32> delay time [nsec] from start of pulse until output of QEreaches quantum control module. Minimal value: 180. Used in measurecommand, to determine the delay between the start of a measurement pulseand the beginning of the demodulation and/or raw data streaming window.singleInput object (single input) specification of the input of a QEwhich has a single input port port string (tuple) of the form ((string)controller name, (int) controller output/input port) operations object Acollection of all pulse names to be used in play and measure commandsproperty_name* string the name of the pulse as it appears under the“pulses” entry in the quantum machine specification digitalInputs objectproperty_name* object (digital input) specification of the digital inputof a QE port string (tuple) of the form ((string) controller name, (int)controller output/input port) delay integer <int32> the digital pulsesplayed to this QE will be delayed by this amount [nsec] relative to theanalog pulses. An intinsic negative delay of 143 + −2nsec exists bydefault output string (tuple) of the form ((string) controller name,(int) controller output/input port) buffer integer <int32> all digitalpulses played to this QE will be convolved with a digital pulse of value1 with this length [nsec] pulses object A collection of pulses to beplayed to the quantum elements. In the case of a measurement pulse, theproperties related to the measurement are specified as well.property_name* object (pulse) specification of a single pulse. Here wedefine its analog and digital components, as well as properties relatedto measurement associated with it. integration_weights object ifmeasurement pulse, a collection of integration weights associated withthis pulse, to be applied to the data output from the QE and sent to thecontroller. Keys: name of integration weights to be used in themeasurement command. property_name* the name of the integration weightsas it appears under the “integration_weigths” entry in the quantummachine specification waveforms a specification of the analog waveformto be played with this pulse. If associated element has singleInput, keyis “single”. If associated element has “mixinputs”, keys are “1” and“Q”. property_name* string name of waveform to be played at the inputport given in associated keys digital_marker string name of the digitalmarker to be played with this pulse operation string type of operation.Possible values: control, measurement length integer <int32> length ofpulse [nsec]. Possible values: 16 to 4194304 in steps of 4 waveformsobject A collection of analog waveforms to be output when a pulse isplayed. Here we specify their defining type (constant, arbitrary orcompressed) and their actual datapoints. property_name* arbitrarywaveform (object) or constant waveform (object) or compressed waveform(object) type ‘arbitrary’ | ‘constant’ | ‘compressed’ samples If type =‘arbitrary’: Array of numbers <float> list of values of arbitrarywaveforms, range: (−0.5, 0.5) If type = ‘constant’: number <float> valueof constant, range: (−0.5, 0.5) If type = ‘compressed’: Array of numbers<float> integer <int32> digital_waveforms object A collection of digitalwaveforms to be output when a pulse is played. Here we specify theiractual datapoints. property_name* object (digital waveform) raw datasamples of a digital waveform samples Array of strings (list of tuples)specifying the analog data according to following code: The first entryof each tuple is 0 or 1 and corresponds to the digital value, and thesecond entry is the length in nsec to play the value, in steps of 1. Ifvalue is 0, the value will be played to integration_weights object Acollection of integration weight vectors used in the demodulation ofpulses returned from a quantum element. property_name* object(integration weights) specification of a set of measurement integrationweights. Result of integration will be: sum over i of(W_cosine[i]cos[wt[i]] + W_sine[i]sin[wt[i]])analog[i]. Here: w is theangular frequency of the quantum element, and analog[i] is the analogdata acquired by the controller. W_cosine, W_sine are the vectorsassociated with the ‘cosine’ and ‘sine’ keys, respectively. Note: theentries in the vector are specified in 4nsec intervals, and each entryis repeated four times during the demodulation. Example: W_cosine =[2.0], W_sine = [0.0] will lead to the following demodulation operation:2.0(cos[wt[0]]analog[0] + cos[wt[l]]analog[1] + cos[wt[2]]analog[2] +cos[wt[3]]analog[3]) sine Array of numbers <float> W_sine, a fixed-pointvector of integration weights, range: [−2048, 2048] in steps of 2**−15cosine Array of numbers <float> W_cosine, a fixed-point vector ofintegration weights, range: [−2048, 2048] in steps of 2**−15 mixersobject A collection of IQ mixer calibration properties, used to post-shape the pulse to compensate for imperfections in the mixers used forupconverting the analog waveforms. property_name* Array of objects(mixer) intermediate_frequency integer <int32> intermediate frequencyassociated with correction matrix lo_freq integer <int32> localoscillator (LO) frequency associated with correction matrix correctionstring (tuple) a 2x2 matrix entered as a four-element tuple specifyingthe correction matrix

Elements of the quantum processor, (e.g. qubits, resonators, flux lines,gates, etc.), external devices (e.g., oscilloscopes, spectrum analyzers,waveform generators, etc.), and/or any other element which is a part ofa quantum machine and is connected to output and/or input ports of thecontroller 210, are defined using one or more of the other propertiesdescribed in Table 4 and/or other similar properties which may be usedin other implementations.

An example of other properties which may be used to specify an elementare properties of a neural network that processes pulses sent to theelement. For example, an element specification may specify that pulsessent to it are to be generates and/or processed by a neural network andthe element definition may include one or more parameters specifying thenumber of layers of the neural network, the number of neurons of theneural network, the weights and biases for each neuron of the neuralnetwork, and/or other parameters familiar to those working with neuralnetworks. The neural network having the specified parameters may then betrained during a calibration routine (e.g., at the beginning ofexecution of a QUA program).

For each element defined in a specification 902, the controller outputand/or input ports to which it is connected are defined. Duringcompilation, pulse modification settings for manipulating pulsesintended for an element may be generated (for loading into pulsemodification settings circuits 504) and the pulse modification settingcircuit(s) 504 to which they will be loaded before execution may bechosen and may be allocated to the quantum machine on which the programis to be executed. Similarly, parameters and configurations ofoperations that will be performed on input signals related to an element(e.g. readout/measurement pulses) may be generated during compilation(for loading into compute and signal processing circuits 410). Likewise,the compute and signal processing circuit 410 in which they will be usedmay be chosen during compilation and may be allocated to the quantummachine on which the program is to be executed during compilation.

One example of an element that a quantum machine may contain is an IQmixer that is connected to two output ports of the controller 210. Tocorrect for mixer imbalances, the in-phase/quadrature (IQ) waveforms ofthe pulse can be multiplied by a 2×2 mixer correction matrix beforebeing sent to the output ports. This mixer correction matrix, determinedvia a calibration routine, may be frequency dependent. Thus, a mixerdefinition may include the mixer's name and a list of one or morefrequencies and the correction matrix to be used at each frequency. Inone example implementation, the correction matrix is loaded intocorresponding pulse modification circuit during compilation. Similarly,an element definition may include an intermediate frequency with whichevery pulse sent to the element is to be modulated.

An example quantum machine specification file is described below withreference to FIGS. 10A-10C. While the example implementations we showhere (including the one Table 4 refers to) show some possible propertiesthat can be defined and specified in the quantum machine specification,it is not limited to these examples. For example, various filters andtheir parameters may be defined (e.g. FIR filter) to be performed onpulses to be played to certain elements and/or on input signals to thecontroller.

Pulses available for transmission by a quantum machine may be definedusing one or more of the properties described in Table 4 and/or othersimilar properties which may be used in other implementations. Eachpulse has a length. Each pulse is made of one or more waveforms. In oneimplementation there are two types of pulses: control pulses that arepulses that are only sent to the quantum system and will not bemeasured, and measurement pulses that are sent to the quantum system andwill be measured upon return. The definition of a measurement pulse mayspecify parameters to be used for processing the measurement pulse uponits return from the element to which it was sent. Such parameters mayinclude, for example, integration weights, parameters (e.g., number oflayers, number of neurons, weights and biases, and/or the like) of aneural network, parameters (e.g., number of taps and tap coefficients)of a FIR filter, and/or the like. During compilation, pulse definitionsmay be used to, for example: generate pulse templates to load into pulsetemplate memory 404; generate instructions to be loaded into instructionmemory 402 and/or compute and signal processing circuit 410 forretrieving and manipulating the contents of pulse template memory 404 toachieve the defined pulses; and/or generate one or more classicalprocessor programs to be executed by compute and signal processingcircuit 410 for processing readout/measurement pulses.

FIGS. 10A-10C show an example quantum machine specification. The exampleshown uses Python as a host language. The example quantum machinespecification is a Python dictionary with a key of “config” and a valuethat comprises a plurality of nested objects, some of which arekey-value pairs and some of which are nested dictionaries.

The “version” key-value pair which indicates the version of the quantummachine specification schema being used.

The “controllers” object is used to specify the number of modules/unitsthat make up the quantum controller 210 of the quantum machine. Theexample shown specifies just a single quantum control module named“con1”, which is of type “opx1” (different opx types may, for example,indicated different hardware and/or configuration of the hardware). Foreach controller 210, the output and input ports that are used in thequantum machine are specified. For analog outputs and inputs, DC offsetvoltage is specified as well.

The “elements” object is used to specify elements that are connected tooutput and input ports of the controller 210. Such elements may includequantum elements (e.g., qubits, readout resonators, flux lines, etc.),external devices (e.g., test equipment such as oscilloscopes, spectrumanalyzers, signal generators, etc.), and/or any other element connectedto the output and/or input ports of the controller. The example shown inFIG. 10A specifies a qubit named “qubit” and a readout resonator named“RR”. The “qubit” element comprises “mixinputs”, “operations”, and“frequency” objects. The “mixinputs” object comprises “I”, “Q”,“lo_frequency”, and “mixer” objects. The “I” and “Q” objects specify thecorresponding output ports of “con1” to which the inputs of the elementare connected. The “intermediate_frequency” object specifies theintermediate frequency with which pulses sent to the qubit are to bemodulated (e.g., determined from a qubit calibration routine). The“mixer” object refers to mixer object “mixer_quibit,” which is definedlater in the quantum machine specification. The “operations” objectspecifies a “gauss-pulse” which refers to the “gauss_pulse_in” object isdefined later in the quantum machine specification. The “RR” elementcomprises “mixinputs”, “operations”, “outputs”, “frequency”,“time_of_flight”, and “smearing” objects. The “mixinputs” objectcomprises “I”, “Q”, “lo_frequency”, and “mixer” objects. The “I” and “Q”objects specify the corresponding ports of “con1”. The “frequency”object specifies the frequency of the readout_resonator (e.g.,determined from a qubit calibration routine). The “mixer” object refersto mixer object “mixer_res,” which is defined later in the quantummachine specification. The “operations” object specifies a “meas_pulse”which refers to the “meas_pulse_in” object is defined later in thequantum machine specification. The “time_of_flight” and “smearing”objects specify those values for the readout resonator. The “outputs”object specifies an output on the element “out1” and the correspondinginput port of “con1” to which it is connected.

The “Pulses” object is used to specify pulses available for transmissionby the quantum machine. The example shown specifies two pulses:“means_pulse_in” and “gauss_pulse_in.” The “means_pulse_in” object inturn comprises “operation”, “length”, “waveforms”,“integration_weights”, and “digital_marker” objects. The “operation”object specifies it as a “measurement” pulse. The “I” and “Q” objects ofthe “waveforms” object refer to the “exc_wf” and “zero_wf” objects whichare defined later in the quantum machine specification. The“integration_weights” object refers to the integration weights objects“integW1” and “integW2” which are defined later in the specification.The “digital_marker” object refers to the “marker1” object defined laterin the specification.

The “gauss_pulse_in” object comprises “operation”, “length”, and“waveforms” objects. The “operation” object specifies it is a “control”pulse. The “I” and “Q” objects of the “waveforms” object refer to the“gauss_wf” and “zero_wf” objects which are defined later in the quantummachine specification.

The “waveforms” object defines the “zero_wf”, “gauss_wf”, and “exc_wf”objects (“exc_wf” not shown) using “type” and “samples” objects.

The “digital_waveforms” defines the “marker1” object using a “samples”object.

The “integration_weights” object defines the objects “integW1” and“integW2” using “cosine” and “sine” objects.

The “mixers” object defines the “mixer_res” and “mixer_qubit” objectsusing “freq”, “lo_freq”, and “correction” objects.

FIG. 11 is a flow chart showing an example process for operation of thequantum orchestration platform. The process begins in block 1102 inwhich one or more quantum control modules are connected together to formquantum controller 210 and the quantum controller 210 is connected to aquantum system. In this regard, the quantum controller 210 is modularand extendable enabling use of as many units as desired/necessary forthe quantum algorithm to be performed. Each of the modules may, forexample, comprise one or more of each of the circuits shown in FIG. 3B.

In block 1103, a quantum machine with a certain specification isinstantiated by a user. This may be done via a Quantum Machines ManagerAPI. In an example of such an API, shown in Table 5, this may include acall to the open_qm( ) function or the open_qm_from_file( ) function.

TABLE 5 Quantum Machines Manager API Class QuantumMachinesManager(host=None, port=None, **kargs)  close_all_quantum_machines( )   ClosesALL open quantum machines  get_controllers( )   Returns a list of allthe quantum control modules that are available  get_qm(machine_id)  Gets an open quantum machine object with the given machine id  Parameters machine_id - The id of the open quantum machine to get  Returns A quantum machine obj that can be used to execute programs list_open_quantum_machines( )   Return a list of open quantum machines.(Returns only the ids, use get_qm(...) to get   the machine object)  Returns   The ids list  open_qm(config, close_other_machines=True) → qm.QuantumMachine.QuantumMachine   Opens a new quantum machine  Parameters   • config - The config that will be used by the namemachine   • close_other_machines - Flag whether to close all otherrunning machines   Returns A quantum machine obj that can be used toexecute programs  open_qm_from_file(filename, close_other_machines=True)  Opens a new quantum machine with config taken from a file on the localfile system   Parameters   • filename - The path to the file thatcontains the config   • close_other_machines - Flag whether to close allother running machines   Returns A quantum machine obj that can be usedto execute programs  perform_healthcheck(strict=True)   Perform a healthcheck against the QM programming subsystem.   Parameters strict - Willraise an exception if health check failed  version( )   Returns The QMprogramming subsystem version

In block 1104, the quantum machines manager 908 attempts to allocatemachine resources (i.e., resources allocated to a particular quantummachine regardless of whether a quantum algorithm description iscurrently executing on that quantum machine) of the quantum controller210 to the new quantum machine according to the specification.

In block 1105, the quantum machines manager 908 determines whether theallocation and instantiation is successful. If not, then in block 1122an alert is generated for the user (e.g., to inform the user that thereare currently insufficient resources available to instantiate therequired quantum machine). If allocation is successful, then in block1106 the allocated resources are stored in quantum machines manager 908,which updates its data structure of available resources to reflect theallocation of resources to the quantum machine, the new quantum machineis instantiated, and the process advances to block 1107.

In block 1107, a user requests to execute a QUA program on the quantummachine. This may be done via a Quantum Machine API. In an example ofsuch an API, shown in Table 6, this may include a call to the execute( )function. Prior to the request to execute the QUA program, and/or duringthe execution of the QUA program, the user can use a Quantum MachineAPI, such as the one shown below in table 6, to alter any parameter thatwas set in the specification 902. This is advantageous where, forexample, something (e.g., temperature, voltage, equipment in use, and/orany other factor that may impact a quantum experiment), has changedsince the time the specification 902 was generated.

TABLE 6 Quantum Machine API Class QuantumMachine (machine_id, pb_config,config, manager)  close( )  Closes the quantum machine. Returns True ifthe close request succeeded, Raises an exception otherwise. execute(pragram, duration_limit=1000, data_limit=20000,force_execution=False, dry_run=  False, **kwargs) → qm.QmJob.QmJobExecutes a program and returns a job object to keep track of executionand get results. Parameters • program - A program( ) object generated inQUA to execute • duration_limit (int) - Maximal time (in msec) for whichresults will be collected. • data_limit (int) - Maximal amount of datasends for which results will be collected. Here data sends is either: 1.4 ADC samples, in case raw data is transferred 2. a single saveoperation • force_execution (bool) - Execute program even if warningsoccur (verify this) • dry_run (bool) - compile program but do not run it(verify this) No new results will be available to the returned jobobject When duration_limit is reached, or when data_limit is reached,whichever occurs sooner. Returns A QmJob object that can be used to keeptrack of the execution and get results  get_config( ) Gives the currentconfig of the qm Returns A dictionary with the qm's config get_dc_offset_by_qe(qe, input) get the current DC offset of the quantumcontrol module analog output channel associated with a quantum element.** remove ** note: not currently implemented. Parameters • qe - the nameof the element to get the correction for • input - the input name asappears in the element's config be more specific here Returns theoffset, in normalized output units  get_digital_buffer(qe,digital_input) get the buffer for digital waveforms of the quantumelement Parameters • qe (str) - the name of the element to get thebuffer for • digital_input (str) - the digital input name as appears inthe element's config Returns the buffer  get_digital_delay(qe,digital_input) Parameters • qe - the name of the element to get thedelay for • digital_input - the digital input name as appears in theelement's config Returns the delay get_io1_value( ) Gives the datastored in OI1 No inference is made on type. Returns A dictionary withdata stored in IO1. (Data is in all three format: int, float, bool) get_io2_value( ) Gives the data stored in IO2 No inference is made ontype. Returns A dictionary with data from the second IO register. (Datais in all three format: int, float, and bool)  get_io_values( ) Givesthe data stored In both IO1 and IO2 No inference is made on type.Returns A list that contains dictionaries with data from the IOregisters. (Data is in all three format: int, float, and bool) get_smearing(qe) get the smearing associated with a measurement quantumelement. This is a broadening of the raw results acquisition window, toaccount for dispersive broadening in the measurement elements (readoutresonators etc.) The acquisition window will be broadened by this amounton both sides. Parameters qe (str) - the name of the element to getsmearing for Returns the smearing, in nsec.  get_time_of_flight(qe) getthe time of flight, associated with a measurement quantum element. Thisis the amount of time between the beginning of a measurement pulseapplied to quantum element and the time that the data is available tothe controller for demodulation or streaming. Parameters qe (str) - thename of the element to get time of flight for Returns the time offlight, in nsec  list_controllers( ) Gives a list with the definedcontrollers in this qm Returns The names of the controllers configuredin this qm  save_config_to_file(filename) Saves the qm current config toa file Parameters filename: The name of the file where the config willbe saved  set_correction(qe, values)  Sets the correction matrix forcorrecting gain and phase imbalances of an IQ mixer associated  with aquantum element.  Parameters  • qe (str) - the name of the element toupdate the correction for  • values (tuple) - 4 value tuple whichrepresents the correction matrix  set_dc_offset_by_qe(qe, input, offset)set the current DC offset of the quantum control module analog outputchannel associated with a quantum element. Parameters • qe (str) - thename of the element to update the correction for • input (str) - theinput name as appears in the element config. Options: ’single’  for anelement with single input ’I’ or ‘Q’  for an element with mixer inputs •offset (float) - the dc value to set to, in normalized output units.Ranges from −0.5 to 0.5 - 2{circumflex over ( )}−16 in steps of2{circumflex over ( )}−16.  set_digital_buffer(qe, digital_input,buffer) set the buffer for digital waveforms of the quantum elementParameters • qe (str) - the name of the element to update buffer for •digital_input (str) - the digital input name as appears in the element'sconfig • buffer (int) - the buffer value to set to, in nsec. Range: 0 to(255 − delay) / 2, in steps of 1  set_digital_delay(qe, digital_input,delay) Sets the delay of the digital waveform of the quantum elementParameters • qe (str) - the name of the element to update delay for •digital_input (str) - the digital input name as appears in the element'sconfig • delay (int) - the delay value to set to, in nsec. Range: 0 to255 − 2 * buffer, in steps of 1  set_frequency(qe, freq) Sets thefrequency of an element, at the output of the mixer, taking LO frequencyinto account. Parameters • qe (str) - the name of the element to updatethe correction for • freq (float) - the frequency to set to the givenelement  set_intermediate_frequency(qe, freq) Sets the intermediatefrequency of the quantum element: Parameters • qe (str) - the name ofthe element to update the intermediate frequency for • freq (float) -the intermediate frequency to set to the given element set_io1_value(value_1) Sets the value of IO1. This can be used laterinside a QUA program as a QUA variable IO1 without declaration. The typeof QUA variable is inferred from the python type passed to value_1,according to the following rule: int −> int float −> fixed bool −> boolParameters value_1 (float | bool | int) - the value to be placed in IO1 set_io2_value(value_2) Sets the value of IO1 This can be used laterinside a QUA program as a QUA variable IO2 without declaration. The typeof QUA variable is inferred from the python type passed to value_2,according to the following rule: int −> int float −> fixed bool −> boolParameters value_1 (float | bool | int) - the value to be placed in IO1 set_io_values(value_1, value_2) Sets the value of IO1 and IO2 This canbe used later inside a QUA program as a QUA variable IO1, IO2 withoutdeclaration. The type of QUA variable is inferred from the python typepassed to value_1, value_2 according to the following rule: int −> intfloat −> fixed bool −> bool Parameters • value_1 (float | bool | int) -the value to be placed in IO1 • value_2 (float | bool | int) - the valueto be placed in IO2  set_smearing(ge, smearing) set the smearingassociated with a measurement quantum element. This is a broadening ofthe raw results acquisition window, to account for dispersive broadeningin the measurement elements (readout resonators etc.) The acquisitionwindow will be broadened by this amount on both sides. Parameters • qe(str) - the name of the element to set smearing for • smearing (int) -the time, in nsec, to broaden the acquisition window. Range: 0 to (255 −time of flight)/2, in steps of 1.  set_time_of_flight(qe,time_of_flight) set the time of flight, associated with a measurementquantum element. This is the amount of time between the beginning of ameasurement pulse applied to quantum element and the time that the datais available to the controller for demodulation or streaming. This timealso accounts for processing delays, which are typically 176nsec.Parameters • qe (str) - the name of the element to set time of flightfor • time_of_flight (int) - the time of flight to set, in nsec. Range:0 to 255 − 2 * smearing, in steps of 4.

In block 1108, compiler 906 receives the quantum machine specificationand the QUA program (e.g., in the form of two plain text files).

In block 1109, compiler 906 attempts to compile the program using thequantum machine specification and the resources of the quantumcontroller 210 that the quantum machines manager 908 indicates areavailable for program execution. During compilation, the compilerdetermines and allocates the program resources of the quantum controller210 that will be used in the program.

In block 1110, the compiler 906 determines whether compilation issuccessful. If not, then in block 1122 an alert is generated for theuser (e.g., to inform the user that there are currently insufficientresources available to execute the program). If compilation issuccessful, then the process advances to block 1112. If compilation issuccessful the compiler outputs the machine code to be loaded to thequantum controller for program execution.

In block 1112, the programming system 202 loads machine code generatedby the compiler 906 based on the program, the quantum machinespecification, and the available resources into quantum controller 210(e.g., via I/O Manager 368).

In block 1114, the programming subsystem 202 determines whether themachine code has been successfully loaded into the quantum controller210. If not, then in block 1122 an alert is generated for the user. Ifthe machine code is successfully loaded, then the process advances toblock 1116.

In block 1116, the program is executed on the quantum controller and thequantum machines manager 908 updates its data structure of availableresources to reflect the allocation of resources to the program.

Either while the program is executing and/or after the program executionis over, the user may change the configuration/specification of thequantum machine. This may be done via a Quantum Machine API, an exampleimplementation of which is shown in Table 6. An example of changing theconfiguration/specification of the quantum machine may be that the useruses the call to the set_frequency(qe, freq) function, which changes thefrequency of the specified element to the specified frequency. Inanother example implementation such quantum machines API may includecommands for changing any parameter defined in the specification (e.g.an API command may allow to change the definition of the samples of aspecified waveform, change the parameters of a neural network associatedwith an element or a pulse, etc.) If the specification is changed whilea program is running on the quantum machine, this may include writing toregisters and/or memory of the quantum controller 210 while the programis executing as well as changing the specification in the quantummachines manager. If the specification is changed while no program isrunning on the quantum machine, this may include only changing thespecification in the quantum machines manager. The ability to altercharacteristics of the quantum machine without closing the quantummachine and even during execution of a QUA program on the quantummachine enables, for example, altering the quantum machine based oncalculations performed on the quantum programming subsystem 202. As anexample, during execution of a QUA program, results may be streamed fromthe quantum controller 210 to the quantum programming subsystem 202, thequantum programming subsystem 202 may perform some calculations usingthe results (e.g., resource-intensive calculations not possible ordesirable to perform on the quantum controller 210) and then update thequantum machine based on the calculations. The update may impact thecurrently running QUA program or a successive run of the same QUAprogram or a different QUA program without having to close the quantummachine for reconfiguration (which may be desirable to, for example,avoid having to repeat a calibration).

In block 1118, upon completing execution of the instructions, theprogram ends and the quantum machines manager 908 updates its datastructure to deallocate the program resources that were allocated tothat program and updates the available resources.

In block 1120, the process can advance either back to block 1107 againin which a user a user requests to execute a QUA program on the quantummachine, or to block 1124 in which a user closes the quantum machine. Ifthe user closes the quantum machine the process advances to block 1126.

In block 1126 the quantum machines manager 908 deallocate the machineresources that were allocated to that quantum machine and updates theavailable resources.

In an example implementation, the pulse generation program 904 iswritten using the QUA programming language.

To aid understanding of the QOP's unique approach to quantum control, ause case example of Power Rabi Calibration will now be described,end-to-end. The use case begins by discussing the theoretical backgroundof the experiment and its goals and showing a typical setup on which itis implemented. It is then shown, step by step, how to program the QOPto perform this experiment, how to execute it, and how to retrieve theresults.

The purpose of Power Rabi Calibration is to measure Rabioscillations—oscillations of the qubit state that are driven by acontrol signal. Assume that the qubit is initially in the ground state(state 0), a drive pulse is applied to rotate the qubit on the Blochsphere around a rotation axis in the x-y plane. The qubit is thenmeasured by calculating the effect of the resonator (that is coupled tothe qubit) on a measurement pulse. The rotation angle, and consequentlythe probability to find the qubit in the excited state (1), depends onthe amplitude of the drive pulse. The protocol is repeated with varyingamplitudes (a). For each amplitude, the protocol is repeated many timesfor averaging, which allows extracting the probability of the qubit tobe in the excited state after the drive pulse is applied. Thisprobability is then plotted as a function of the drive amplitude, fromwhich the rotation angle, as a function of the amplitude, can beextracted. This experiment provides an important tool for calibratingquantum gates. For example, the amplitude at which the qubit reaches arotation of 180 degrees gives us the required amplitude for performingan X-gate (the quantum NOT gate). Similarly, this program can be run toidentify the amplitude required to perform a π/2-rotation.

The example experiment setup is shown in FIG. 12A. The quantum device isa superconducting circuit composed of a single, fixed frequency qubitand a readout resonator, with the following Hamiltonian:

$H = {{\frac{\hslash}{2}\omega_{Q}\sigma_{Z}} + {{\hslash\omega}_{R}a^{\dagger}a} + {\hslash{{g\left( {{a^{\dagger}\sigma^{-}} + {a\sigma^{+}}} \right)}.}}}$

Since the interaction between the qubit and resonator is dispersive(|ω_(R)−ω_(Q)|), an approximation can be made that leads to thefollowing form of the Hamiltonian:

$H = {{\frac{\hslash}{2}\left( {\omega_{Q} + \frac{g^{2}}{\Delta}} \right)\sigma_{Z}} + {{\hslash\left( {\omega_{R} + {\frac{g^{2}}{\Delta}\sigma_{Z}}} \right)}a^{\dagger}a}}$Where Δ=ω_(Q)−ω_(R). Finally, the qubit driving term can be explicitlyincluded, which leads to the Hamiltonian:

$H = {H_{0} + {\hslash{s(t)}\sigma_{x^{.}}} + {\frac{m(t)}{2}\left\lbrack {{a^{\dagger}e^{{- i}\omega t}} + {ae^{i\omega t}}} \right\rbrack}}$

Here it is assumed that the frequencies of both the qubit and theresonator were calibrated in advance.

A signal, at the resonance frequency of the qubit, of the forms(t)=A cos(ω_(Q) t+ϕ)rotates the Bloch vector of the qubit at a rate A around the axis whichis on the x-y plane and is rotated by an angle φ from the x-axis.

If the parameters A(t) and φ(t) are varied slowly compared to ω_(Q),then this still holds at each point in time. Thus, if a pulse is sent(i.e. a signal that is finite in time) to the qubit of the forms(t)=A(t)cos(ω_(Q) t+ϕ)where A(t) varies slowly compared to ω_(Q), the Bloch vector will berotated around the above axis by a total angle which is given by theintegral of A(t):θ=∫_(t) ₀ ^(t) ⁰ ^(+τ) +TA(t)dt.Here t₀ is the time at which the pulse starts and t is the duration ofthe pulse.

In a typical Power Rabi Oscillations experiment, the shape and durationof the pulse A(t) are fixed (e.g. a 20-nanosecond gaussian pulse) andonly its amplitude is varied in order to get different rotation anglesθ. The experiment performed by repeating the following basic sequence:

(1) Initialize the qubit to the ground state, 0.

(2) Apply a pulse with amplitude a (e.g. A(t) is a Gaussian shaped pulsewith peak amplitude a, which rotates the qubit by θ so that the qubit isin the statecos(θ_(a))|0

+e ^(iϕ) sin(θ_(a))|1

.(3) Apply a resonant pulse to the readout resonator, and from the phaseof the reflected pulse, deduce the state of the qubit.

This basic sequence is repeated in the program for a series ofamplitudes (i.e., many values of a), where for each amplitude, a, it isrepeated N times (i.e. N identical basic sequences with the same a). Nidentical measurements are required because of state collapse. Themeasurement at the end of each basic sequence gives a binary result (0or 1) for the state of the qubit, even if before the measurement thequbit was in a superposition state. However, when the results of the Nidentical basic sequences are averaged, the average will be ˜sin²(θ).Denote this average as

(a) since it reflects the probability of measuring the qubit in the |1

state for a given amplitude, a. The results of the whole experiment canbe summarized by plotting

(a) as a function of a (see FIG. 12B).

This can be used to calibrate any single qubit rotation gate thatrotates the qubit by an angle θ, around a rotation axis that is on thex-y plane and is rotated φ from the x-axis. Such a gate is denoted byR_(ϕ(θ)). In fact, one of the typical goals of the Power RabiOscillations experiment is to calibrate the amplitude of a given pulseso that it performs π-rotation (X-gate) or π/2-rotation. φ, however,cannot be determined from the Rabi oscillations and must be determinedby other means (e.g. tomography).

An example implementation of the Power Rabi experiment in the QOP willnow be described.

The experiment is implemented on the QOP as follows: (1) Defining aquantum machine specification; (2) Opening an interface to the quantummachine; (3) Writing the program; (4) Running the program; (5) Savingthe results

As discussed above, the quantum machine specification is a descriptionof the physical elements present in the experimental setup and theirproperties, as well as the connectivity between the elements and thequantum control module(s). The physical elements that are connected tothe quantum control module(s) are denoted in the quantum machinespecification as elements, which are discrete entities such as qubits,readout resonators, flux lines, gate electrodes, etc. Each of these hasinputs and in some cases outputs, connected to the quantum controlmodule(s). The properties of the elements and their connectivity to thequantum control module(s) are used by the QOP to interpret and executeQUA programs correctly (e.g. a pulse played to a certain qubit ismodulated by the quantum control module with the intermediate frequencydefined for this element). The quantum machine specification in FIGS.10A-10C is used for this particular example.

The pulses applied to the elements are also specified in the quantummachine specification, where each pulse is defined as a collection oftemporal waveforms. For example, a pulse to an element with two analoginputs and one digital input will specify the two waveforms applied tothe analog inputs of the element and the digital pulse applied to itsdigital input.

Also defined in the quantum machine specification are the properties ofany auxiliary components that affect the actual output of thecontroller, such as IQ mixers and local oscillators.

After defining the quantum machine specification, an interface to a newquantum machine can be opened with the following command:

-   -   my_qm=qmManager.open_qm(my_config)

After having defined the quantum machine specification, write the QUAprogram. Below is the power Rabi program.

with program( ) as powerRabiProg :  I = declare(fixed)  Q =declare(fixed)  a = declare(fixed)  Nrep = declare(int)  with for_(Nrep,0, Nrep < 100, Nrep + 1):   with for_(a, 0.00, a <= 1.0, a + 0.01):   play(‘gauss_pulse’*amp(a), ‘qubit’)    align(“qubit”, “RR”)   measure(‘meas_pulse’, ‘RR’, ‘samples’,(‘integW1’,I),    (‘integW2’,Q))    save(I, ‘I’)    save(Q, ‘Q’)    save(a, ‘a’)

The program is very intuitive to someone who knows the theory of thePower Rabi calibration, which illustrates one of the benefits of theQOP: the ability for people (e.g., quantum physicists) to rapidly designand run quantum experiments without first having to become expertprogrammers or computer systems designers. This is in stark contrast tocurrent systems which, for example, require quantum physicists to learna hardware description language such as VHDL or Verilog to be able torun their quantum experiments/algorithms.

This program: (1) Defines the variables a (amplitude) and Nrep (numberof repetitions), as well as the variables I and Q, which store thedemodulation result; and (2) Performs 100 repetitions (the loop overNrep), where in each scan loops over 100 values of a, from 0-1 inincrements of 0.01 and for each value of a performs the Rabi sequence:playing a pulse with amplitude a to the qubit, then measuring theresonator response and extracting from it the state of the qubit. Thisis done by sending a measurement pulse to the resonator and demodulatingand integrating the returning pulse using the indicated integrationweights.

The raw data sampled at the quantum control module's input is alsostreamed and saved with the label ‘samples.’ Finally, the demodulationand integration results, I and Q, are saved as well as the correspondingamplitude.

This Python code block creates an object named powerRabiProg, which is aQUA program that can be executed on an open quantum machine.

The program is run on a quantum machine “my_qm” defined in the quantummachine specification using the following command which saves theresults in the job object “my_job.”

-   -   myjob=my_qm.execute(powerRabiProg)

After the program is executed, the results can be pulled:

-   -   my_powerRabi_results=job.get_results( )

This command pulls the results from “myjob” to the results object“my_powerRabi_results”.

The data in “my_powerRabi_results” is a Python object which contains thevariables saved during the program, as well as all the raw data sampledat the input of the quantum control module. Here, “my_powerRabi_results”will have: (1) my_powerRabi_results.variable_results, which will be adictionary containing three keys: ‘I’, ‘Q’ and ‘a’. The value for eachkey will be a dictionary containing the saved data and the time stampfor each saved data point; (2) my_powerRabi_results.raw_results, whichwill be a dictionary containing a single key and its value will be adictionary containing the sampled input data and the timestamp of eachdata point.

In accordance with an example implementation of this disclosure, asystem comprises pulse generation and measurement circuitry (e.g., 210)comprising a plurality of pulse generator circuits (e.g., 302) and aplurality of ports (e.g., ports of signal path(s) 304, 306, and/or 308),and management circuitry (e.g., 202 and part of 210). The managementcircuitry is operable to analyze a specification of a control system andcontrolled elements (e.g., specification 902) that comprises adefinition of a controlled element of the control system, and adefinition of one or more pulses available for transmission by thecontrol system. The management circuitry is operable to configure, basedon the specification, the pulse generation and measurement circuitry to:generate the one or more pulses via one or more of the plurality ofpulse generator circuits; and output the one or more pulses to thecontrolled element via one or more of the plurality of ports. Theconfiguration of the pulse generation and measurement circuitry maycomprise generation of one or more pulse modification settings andstorage of the one or more pulse modification settings to pulsemodification circuitry (e.g., 504 ₀-504 _(K−1)) of the pulse generationand measurement circuitry. The configuration of the pulse generation andmeasurement circuitry may comprise generation of pulse templates andstorage of the pulse templates to pulse memory (404) of the pulsegeneration and measurement circuitry. The configuration of the pulsegeneration and measurement circuitry may comprise generation ofinstructions for a processor (e.g., 410) of the pulse generation andmodification circuitry to perform classical computations and storage ofthe instructions to the processor. The configuration of the pulsegeneration and measurement circuitry may comprise generation of digitalsignal processing path configuration settings and storage of the digitalsignal processing path configuration settings to digital signalgeneration circuitry (e.g., 376) of the pulse generation and measurementcircuitry. The definition of the controlled element may specify whetherthe controlled element is to be controlled with independent pulses orwith two-pair pulses (e.g., via “singleInput” and “mixInputs”properties). The definition of the controlled element may specify afrequency with which pulses sent to the controlled element are to bemodulated (e.g., via an “intermediate_frequency” property). Thedefinition of the controlled element may specify which of the one ormore pulses are to be available for transmission to the controlledelement (e.g., via an “operations” property). The definition of thecontrolled element may specify which of the plurality of ports areconnected to which of one or more inputs of the controlled element ofthe first control system (e.g., via “mixinputs” or “singleInput”properties). The definition of the controlled element may specifywhether the controlled element has an output (e.g., via an “outputs”property), and, if the controlled element has an output, one or moretiming parameters to be used for receiving signals from the controlledelement (e.g., via “smearing” and/or “time-of-flight” property). The oneor more timing parameters determine, at least in part, one or both of: aduration of an acquisition window; and a delay between when a pulse istransmitted to the controlled element and when measurement of a signalfrom the controlled element should begin. The definition of thecontrolled element may specify one or more digital inputs of thecontrolled element (e.g., via a “digital inputs” property). Thedefinition of the controlled element may specify a delay between a sendtime of a pulse destined for the controlled element and a send time of adigital signal accompanying the pulse destined for the controlledelement (e.g., via a “delay” property). The definition of the controlledelement may specify convolution parameters and/or delay parameters foruse with digital signals sent to the controlled element (e.g., via a“buffer”. The definition of the controlled element may specify a circuitelement associated with the controlled element (e.g., in the signal pathto the controlled element), The circuit element may be a of particulartype (e.g., a mixer) specified by a property named after the type ofcircuit (e.g., “mixer”)). The control system specification comprises adefinition of the circuit element, and the definition of the circuitelement may comprise a parameter for compensating for nonidealities ofthe circuit element (e.g., a mixer correction matrix). The definition ofthe one or more pulses may specify one or more parameters to be used forprocessing signals from the controlled element (e.g., integrationweights, a filter transfer function, etc.). The specification maycomprise a definition of the one or more parameters, which may take theform of a plurality of vectors. The definition of the one or more pulsesmay specify one or more waveforms to be used for generation of the oneor more pulses (e.g., via a “waveforms” property). The specification maycomprise a definition of the one or more waveforms. The definition ofthe one or more waveforms which may take the form of a collection (e.g.,list, string, array, etc.) of samples of the one or more waveforms. Thedefinition of the one or more pulses may specify one or more digitalsignals that are to be output along with the one or more pulses. Thespecification may comprise a definition of the one or more digitalsignals. The definition of the one or more digital signals may specifythe digital values of the one or more digital signals and how long eachof the digital values is to be output. The management circuitry may beoperable to receive commands via an application programming interface(e.g., a quantum machine API, an example of which is shown in Table 6),and the configuration may be based on the commands such that thecommands supplement the specification and/or override one or moredefinitions in the specification.

The present method and/or system may be realized in hardware, software,or a combination of hardware and software. The present methods and/orsystems may be realized in a centralized fashion in at least onecomputing system, or in a distributed fashion where different elementsare spread across several interconnected computing systems. Any kind ofcomputing system or other apparatus adapted for carrying out the methodsdescribed herein is suited. A typical implementation may comprise one ormore application specific integrated circuit (ASIC), one or more fieldprogrammable gate array (FPGA), and/or one or more processor (e.g., ×86,×64, ARM, PIC, and/or any other suitable processor architecture) andassociated supporting circuitry (e.g., storage, DRAM, FLASH, businterface circuits, etc.). Each discrete ASIC, FPGA, Processor, or othercircuit may be referred to as “chip,” and multiple such circuits may bereferred to as a “chipset.” Another implementation may comprise anon-transitory machine-readable (e.g., computer readable) medium (e.g.,FLASH drive, optical disk, magnetic storage disk, or the like) havingstored thereon one or more lines of code that, when executed by amachine, cause the machine to perform processes as described in thisdisclosure. Another implementation may comprise a non-transitorymachine-readable (e.g., computer readable) medium (e.g., FLASH drive,optical disk, magnetic storage disk, or the like) having stored thereonone or more lines of code that, when executed by a machine, cause themachine to be configured (e.g., to load software and/or firmware intoits circuits) to operate as a system described in this disclosure.

As used herein the terms “circuits” and “circuitry” refer to physicalelectronic components (i.e. hardware) and any software and/or firmware(“code”) which may configure the hardware, be executed by the hardware,and or otherwise be associated with the hardware. As used herein, forexample, a particular processor and memory may comprise a first“circuit” when executing a first one or more lines of code and maycomprise a second “circuit” when executing a second one or more lines ofcode. As used herein, “and/or” means any one or more of the items in thelist joined by “and/or”. As an example, “x and/or y” means any elementof the three-element set {(x), (y), (x, y)}. As another example, “x, y,and/or z” means any element of the seven-element set {(x), (y), (z), (x,y), (x, z), (y, z), (x, y, z)}. As used herein, the term “exemplary”means serving as a non-limiting example, instance, or illustration. Asused herein, the terms “e.g.,” and “for example” set off lists of one ormore non-limiting examples, instances, or illustrations. As used herein,circuitry is “operable” to perform a function whenever the circuitrycomprises the necessary hardware and code (if any is necessary) toperform the function, regardless of whether performance of the functionis disabled or not enabled (e.g., by a user-configurable setting,factory trim, etc.). As used herein, the term “based on” means “based atleast in part on.” For example, “x based on y” means that “x” is basedat least in part on “y” (and may also be based on z, for example).

While the present method and/or system has been described with referenceto certain implementations, it will be understood by those skilled inthe art that various changes may be made and equivalents may besubstituted without departing from the scope of the present methodand/or system. In addition, many modifications may be made to adapt aparticular situation or material to the teachings of the presentdisclosure without departing from its scope. Therefore, it is intendedthat the present method and/or system not be limited to the particularimplementations disclosed, but that the present method and/or systemwill include all implementations falling within the scope of theappended claims.

What is claimed is:
 1. A system comprising: a plurality of pulsegenerator circuits, wherein the plurality of pulse generator circuitscomprises a plurality of output ports; and a pulse management circuitoperable to receive a definition of one or more pulses and a selectionof one or more output ports of the plurality of output ports, wherein:the pulse management circuit is operable to configure the plurality ofpulse generator circuits to output the one or more pulses from the oneor more output ports, an RF signal is generated according to the one ormore pulses, and the RF signal is configured to interact with a quantumelement.
 2. The system of claim 1, wherein the system comprises a pulsemodification circuit operably coupled between the plurality of pulsegenerator circuits and the quantum element, wherein the pulsemodification circuit is configurable according to one or more pulsemodification settings.
 3. The system of claim 1, wherein the systemcomprises a pulse memory operable to store a pulse template, and whereinthe pulse template is used to configure the plurality of pulse generatorcircuits.
 4. The system of claim 1, wherein the system comprises aprocessor that is operable to perform classical computations, andwherein the configuration of the plurality of pulse generator circuitscomprises generation of instructions for the processor.
 5. The system ofclaim 1, wherein the configuration of the plurality of pulse generatorcircuits comprises a generation of instructions to be executed by theplurality of pulse generator circuits.
 6. The system of claim 1, whereinthe system comprises a digital signal generator, and wherein theconfiguration of the plurality of pulse generator circuits comprises ageneration of digital signal processing settings for the digital signalgenerator.
 7. The system of claim 1, wherein: the configuration of theplurality of pulse generator circuits is based on whether the quantumelement is to be controlled with independent pulses or with two-pairpulses.
 8. The system of claim 1, wherein the one or more pulses aremodulated on a selectable frequency.
 9. The system of claim 1, whereinthe configuration of the plurality of pulse generator circuits operatesaccording to one or more timing parameters, and wherein the one or moretiming parameters are used for receiving signals from the quantumelement.
 10. The system of claim 9, wherein the one or more timingparameters determine, at least in part, one or both of a duration of anacquisition window and a delay between when a pulse is transmitted tothe quantum element and when measurement of a signal from the quantumelement should begin.
 11. The system of claim 1, wherein theconfiguration of the plurality of pulse generator circuits uses the oneor more digital inputs.
 12. The system of claim 1, wherein theconfiguration of the plurality of pulse generator circuits uses aconvolution parameter and/or a delay parameter.
 13. The system of claim1, wherein the system comprises a mixer operably coupled between theplurality of pulse generator circuits and the quantum element.
 14. Thesystem of claim 13, wherein the mixer is configurable according to amixer correction matrix.
 15. The system of claim 1, wherein theplurality of pulse generator circuits are configured according to aplurality of vectors.
 16. The system of claim 1, wherein the pluralityof pulse generator circuits are configured according to one or moreparameters of a neural network.
 17. The system of claim 1, wherein theone or more pulses are defined by a collection of samples of one or morewaveforms.
 18. The system of claim 1, wherein the plurality of pulsegenerator circuits are operable to generate one or more digital signals.19. The system of claim 1, wherein the configuration is based oncommands received via an application programming interface.